From c54aa6999f36746f40a5d11a41911a13e2bdb14f Mon Sep 17 00:00:00 2001
From: "Shahid N. Shah" <shahid@shah.org>
Date: Wed, 21 Aug 2024 21:35:25 -0400
Subject: [PATCH] refactor: sqlpage aide moved to RSC

---
 lib/sqlpage/README.md       | 199 ----------
 lib/sqlpage/component.ts    | 729 ------------------------------------
 lib/sqlpage/mod.ts          |   3 -
 lib/sqlpage/mod_test.ts     | 145 -------
 lib/sqlpage/render.ts       | 120 ------
 lib/sqlpage/sqlpage-aide.ts | 649 --------------------------------
 6 files changed, 1845 deletions(-)
 delete mode 100644 lib/sqlpage/README.md
 delete mode 100644 lib/sqlpage/component.ts
 delete mode 100644 lib/sqlpage/mod.ts
 delete mode 100644 lib/sqlpage/mod_test.ts
 delete mode 100644 lib/sqlpage/render.ts
 delete mode 100644 lib/sqlpage/sqlpage-aide.ts

diff --git a/lib/sqlpage/README.md b/lib/sqlpage/README.md
deleted file mode 100644
index 73279496..00000000
--- a/lib/sqlpage/README.md
+++ /dev/null
@@ -1,199 +0,0 @@
-# SQLPageAide
-
-## Introduction to SQLPage
-
-SQLPage is an open-source web server written in Rust, designed to build web
-applications entirely using SQL. It allows users to write SQL queries that are
-executed on a database, and the results are rendered as web pages. This utility
-is particularly useful for those who are proficient in SQL but may not have
-extensive experience with traditional web programming languages like HTML, CSS,
-or JavaScript.
-
-SQLPage operates by mapping the results of SQL queries to pre-defined web
-components, such as tables, charts, forms, and more. These components can be
-customized using HTML templates, providing flexibility in how the data is
-presented. The tool supports multiple databases, including SQLite, PostgreSQL,
-MySQL, and Microsoft SQL Server.
-
-The primary appeal of SQLPage is its simplicity and ease of use. Developers can
-get started quickly by downloading a single executable file, writing SQL
-queries, and immediately seeing the results as a functional website. It's
-particularly well-suited for data analysts, business intelligence teams, and
-others who need to build data-centric applications without getting into the
-complexities of full-stack web development.
-
-SQLPage also supports advanced features like user authentication, file uploads,
-and HTTPS. It can be deployed on various platforms, including local servers and
-cloud environments, and supports integration with Docker for easy deployment.
-
-For more detailed information and examples, you can explore the documentation
-and discussions available on
-[SQLPage's GitHub](https://github.com/lovasoa/SQLpage) and related resources.
-
-## Structure of `sqlpage_files` Table
-
-The `sqlpage_files` table in SQLPage serves as a storage mechanism within the
-database to host files used by the application. The structure of this table
-includes the following columns:
-
-- **path**: A text or string field that stores the file path or identifier. This
-  path is used to reference the file within the SQLPage application, allowing it
-  to be served or accessed as needed.
-
-- **contents**: A BLOB (Binary Large Object) field that contains the actual file
-  data. This could be anything from images, JSON files, configuration files, or
-  other binary content. Storing the file data in BLOB format ensures that binary
-  data can be stored and retrieved accurately.
-
-- **last_modified**: A timestamp field that records the last time the file was
-  modified. This is useful for caching, version control, and ensuring that the
-  most up-to-date version of the file is served.
-
-This structure allows SQLPage to serve files dynamically from the database,
-enabling features like localization, theming, and dynamic content management
-directly within SQLPage applications.
-
-## SQLPageAide class
-
-`SQLPageAide` is a utility class designed to facilitate the creation of upsert
-statements for inserting records into `sqlpage_files` table. `SQLPageAide` does
-not operate on a database, it just generates SQL.
-
-## Key Features
-
-- **No Dependencies**: Does not depend on SQLa or any other library but can use
-  all of SQLa if desired.
-- **Structured Definitions**: Define SQL page paths and contents using classes
-  or objects.
-- **Convenience Functions**:
-  - `sources()`: Specify the classes or objects containing SQL definitions.
-  - `includeUpserts()`: Include specific patterns to match method names that
-    will generate Upsert content (defaults to /*.sql$/).
-  - `excludeUpserts()`: Exclude specific patterns from matching method names
-    that will generate Upsert content.
-  - `includeSql()`: Include specific patterns to match method names that will
-    generate general SQL statements to incorporate before upserts.
-  - `excludeSql()`: Exclude specific patterns from matching method names that
-    will generate general SQL statements to incorporate before upserts.
-  - `withContentsArgs()`: Inject additional context or arguments into SQL
-    methods for dynamic content.
-  - `pathContents()`: Customize the method selection process for upserting into
-    `sqlpage_files`.
-- **Automatic Upsert Generation**:
-  - `upsertValues()`: Collects and prepares SQL statements for insertion or
-    update.
-  - `SQL()`: Generates SQL statements to manage entries in the `sqlpage_files`
-    table.
-
-## Usage Examples
-
-### Basic Example
-
-Define a class with SQL methods and use SQLPageAide to generate SQL upsert
-statements.
-
-```typescript
-// Define a class with SQL methods
-class MySqlPages {
-  "index.sql"() {
-    return "SELECT * FROM users;";
-  }
-
-  "page1.sql"() {
-    return "INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com');";
-  }
-}
-
-// Generate SQL statements
-const sqlAide = new SQLPageAide(MySqlPages);
-const sqlStatements = sqlAide.SQL();
-console.log(sqlStatements);
-// Output:
-// INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('index.sql', 'SELECT * FROM users;', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents=excluded.contents, last_modified=CURRENT_TIMESTAMP);
-// INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('page1.sql', 'INSERT INTO users (name, email) VALUES (''John Doe'', ''john@example.com'');', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents=excluded.contents, last_modified=CURRENT_TIMESTAMP);
-```
-
-### Using Contents Args Supplier
-
-Inject additional arguments into SQL methods for dynamic content generation.
-
-```typescript
-class MySqlPages {
-  "index.sql"(user: string) {
-    return `SELECT * FROM users WHERE name = '${user}';`;
-  }
-}
-
-const sqlPageAide = new SQLPageAide(MySqlPages)
-  .withContentsArgs((_source, _path, user: string) => [user]);
-
-const sqlStatements = sqlPageAide.SQL("John Doe");
-console.log(sqlStatements);
-// Output:
-// INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('index.sql', 'SELECT * FROM users WHERE name = ''John Doe'';', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents=excluded.contents, last_modified=CURRENT_TIMESTAMP);
-```
-
-### Including and Excluding Methods
-
-Include or exclude specific methods based on patterns.
-
-```typescript
-class MySqlPages {
-  "index.sql"() {
-    return "SELECT * FROM users;";
-  }
-
-  "page1.sql"() {
-    return "INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com');";
-  }
-
-  "admin.sql"() {
-    return "SELECT * FROM admins;";
-  }
-}
-
-const sqlAide = new SQLPageAide(MySqlPages)
-  .include(/index\.sql/, /page1\.sql/)
-  .exclude(/admin\.sql/);
-
-const sqlStatements = sqlAide.SQL();
-console.log(sqlStatements);
-// Output includes only statements for index.sql and page1.sql, excluding admin.sql.
-```
-
-### Custom Path Contents Supplier
-
-Customize the method selection process.
-
-```typescript
-class MySqlPages {
-  "index.sql"() {
-    return "SELECT * FROM users;";
-  }
-
-  "page1.sql"() {
-    return "INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com');";
-  }
-
-  "admin.sql"() {
-    return "SELECT * FROM admins;";
-  }
-}
-
-const customPathContentsSupplier = (
-  sp: SourcePaths<MySqlPages>,
-  includePatterns: PathPattern[],
-  excludePatterns: PathPattern[],
-) => {
-  return sp.paths.filter((path) =>
-    path.startsWith("index") || path.startsWith("page")
-  );
-};
-
-const sqlAide = new SQLPageAide(MySqlPages)
-  .pathContents(customPathContentsSupplier);
-
-const sqlStatements = sqlAide.SQL();
-console.log(sqlStatements);
-// Output includes statements for index.sql and page1.sql, based on custom supplier logic.
-```
diff --git a/lib/sqlpage/component.ts b/lib/sqlpage/component.ts
deleted file mode 100644
index 72418001..00000000
--- a/lib/sqlpage/component.ts
+++ /dev/null
@@ -1,729 +0,0 @@
-export interface Component<Identity> {
-  readonly component: Identity;
-  readonly title?: string;
-}
-
-export interface RenderedComponent<T extends Component<string>> {
-  readonly component: T;
-  readonly SQL: (() => string) | string | string[];
-}
-
-export interface Alert extends Component<"alert"> {
-  readonly message: string;
-  readonly type?: "info" | "warning" | "error";
-}
-
-export interface Authentication extends Component<"authentication"> {
-  readonly link: string;
-  readonly token?: string;
-}
-
-export interface Breadcrumb extends Component<"breadcrumb"> {
-  readonly items: readonly BreadcrumbItem[];
-}
-
-export interface BreadcrumbItem {
-  readonly label: string;
-  readonly link: string;
-}
-
-export interface Button extends Component<"button"> {
-  readonly buttons: readonly ButtonItem[];
-}
-
-export interface ButtonItem {
-  readonly label: string;
-  readonly link: string;
-  readonly style?: "primary" | "secondary" | "danger";
-}
-
-export interface Card extends Component<"card"> {
-  readonly items: readonly CardItem[];
-}
-
-export interface CardItem {
-  readonly title: string;
-  readonly content: string;
-  readonly image?: string;
-  readonly link?: string;
-}
-
-export interface Carousel extends Component<"carousel"> {
-  readonly images: readonly CarouselImage[];
-}
-
-export interface CarouselImage {
-  readonly src: string;
-  readonly alt?: string;
-}
-
-export interface Chart extends Component<"chart"> {
-  readonly type: "line" | "bar" | "pie" | "area";
-  readonly data: readonly ChartDataPoint[];
-}
-
-export interface ChartDataPoint {
-  readonly x: string | number;
-  readonly y: number;
-}
-
-export interface Code extends Component<"code"> {
-  readonly language: string;
-  readonly code: string;
-}
-
-export interface Cookie extends Component<"cookie"> {
-  readonly name: string;
-  readonly value: string;
-  readonly path?: string;
-  readonly expires?: string;
-}
-
-export interface Csv extends Component<"csv"> {
-  readonly filename: string;
-  readonly columns: readonly string[];
-}
-
-export interface DataGrid extends Component<"datagrid"> {
-  readonly items: readonly DataGridItem[];
-}
-
-export interface DataGridItem {
-  readonly name: string;
-  readonly value: string;
-}
-
-export interface Debug extends Component<"debug"> {
-  readonly data: unknown;
-}
-
-export interface Divider extends Component<"divider"> {
-  readonly style?: string;
-}
-
-export interface Dynamic extends Component<"dynamic"> {
-  readonly content: string;
-}
-
-export interface Form extends Component<"form"> {
-  readonly fields: readonly FormField[];
-  readonly action: string;
-}
-
-export interface FormField {
-  readonly name: string;
-  readonly type:
-    | "text"
-    | "password"
-    | "email"
-    | "number"
-    | "date"
-    | "textarea"
-    | "select"
-    | "checkbox"
-    | "radio";
-  readonly placeholder?: string;
-  readonly required?: boolean;
-  readonly options?: readonly string[]; // for select fields
-  readonly label?: string;
-  readonly min?: number;
-  readonly max?: number;
-  readonly step?: number;
-  readonly minlength?: number;
-  readonly maxlength?: number;
-  readonly pattern?: string;
-  readonly autocomplete?: "on" | "off" | string;
-  readonly autofocus?: boolean;
-  readonly description?: string;
-  readonly checked?: boolean;
-}
-
-export interface Hero extends Component<"hero"> {
-  readonly description?: string;
-  readonly image?: string;
-  readonly link?: string;
-  readonly linkText?: string;
-}
-
-export interface Html extends Component<"html"> {
-  readonly content: string;
-}
-
-export interface HttpHeader extends Component<"http_header"> {
-  readonly headers: Record<string, string>;
-}
-
-export interface Json extends Component<"json"> {
-  readonly data: unknown;
-}
-
-export interface List extends Component<"list"> {
-  readonly items: readonly ListItem[];
-}
-
-export interface ListItem {
-  readonly title: string;
-  readonly link?: string;
-  readonly description?: string;
-  readonly icon?: string;
-  readonly active?: boolean;
-  readonly color?: string;
-  readonly delete_link?: string;
-  readonly edit_link?: string;
-  readonly image_url?: string;
-  readonly view_link?: string;
-}
-
-export interface Map extends Component<"map"> {
-  readonly markers: readonly MapMarker[];
-}
-
-export interface MapMarker {
-  readonly latitude: number;
-  readonly longitude: number;
-  readonly label?: string;
-}
-
-export interface Redirect extends Component<"redirect"> {
-  readonly url: string;
-}
-
-export interface Rss extends Component<"rss"> {
-  readonly url: string;
-  readonly title: string;
-  readonly description?: string;
-}
-
-export interface Shell extends Component<"shell"> {
-  readonly layout?: "boxed" | "horizontal" | "fluid";
-  readonly css?: string;
-  readonly favicon?: string;
-  readonly javascript?: string;
-  readonly language?: string;
-  readonly theme?: "dark" | "light";
-  readonly title: string;
-  readonly description?: string;
-  readonly image?: string;
-  readonly manifest?: string;
-  readonly menu_item?: string | { title: string; submenu: readonly MenuItem[] };
-  readonly norobot?: boolean;
-  readonly refresh?: number;
-  readonly rss?: string;
-  readonly search_target?: string;
-  readonly search_value?: string;
-  readonly social_image?: string;
-}
-
-export interface MenuItem {
-  readonly title: string;
-  readonly link: string;
-}
-
-export interface Steps extends Component<"steps"> {
-  readonly steps: readonly StepItem[];
-}
-
-export interface StepItem {
-  readonly label: string;
-  readonly link: string;
-}
-
-export interface Tab extends Component<"tab"> {
-  readonly tabs: readonly TabItem[];
-}
-
-export interface TabItem {
-  readonly label: string;
-  readonly link: string;
-  readonly active?: boolean;
-}
-
-export interface Table extends Component<"table"> {
-  readonly columns: readonly TableColumn[];
-  readonly sort?: boolean;
-  readonly search?: boolean;
-}
-
-export interface TableColumn {
-  readonly name: string;
-  readonly label?: "markdown" | string;
-}
-
-export interface Text extends Component<"text"> {
-  readonly content: string;
-}
-
-export interface Timeline extends Component<"timeline"> {
-  readonly events: readonly TimelineEvent[];
-}
-
-export interface TimelineEvent {
-  readonly timestamp: string;
-  readonly description: string;
-}
-
-export interface Title extends Component<"title"> {
-  readonly level?: 1 | 2 | 3 | 4 | 5 | 6;
-  readonly contents: string;
-}
-
-export interface Tracking extends Component<"tracking"> {
-  readonly logs: readonly TrackingLog[];
-}
-
-export interface TrackingLog {
-  readonly timestamp: string;
-  readonly action: string;
-  readonly user?: string;
-}
-
-export function alertSQL(component: Alert): RenderedComponent<Alert> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.message}' AS message${
-        component.type ? `, '${component.type}' AS type` : ""
-      };`,
-    ],
-  };
-}
-
-export function authenticationSQL(
-  component: Authentication,
-): RenderedComponent<Authentication> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.link}' AS link${
-        component.token ? `, '${component.token}' AS token` : ""
-      };`,
-    ],
-  };
-}
-
-export function breadcrumbSQL(
-  component: Breadcrumb,
-): RenderedComponent<Breadcrumb> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.items.map((item) =>
-        `SELECT '${item.label}' AS label, '${item.link}' AS link;`
-      ),
-    ],
-  };
-}
-
-export function buttonSQL(component: Button): RenderedComponent<Button> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.buttons.map((button) =>
-        `SELECT '${button.label}' AS label, '${button.link}' AS link${
-          button.style ? `, '${button.style}' AS style` : ""
-        };`
-      ),
-    ],
-  };
-}
-
-export function cardSQL(component: Card): RenderedComponent<Card> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.items.map((item) =>
-        `SELECT '${item.title}' AS title, '${item.content}' AS content${
-          item.image ? `, '${item.image}' AS image` : ""
-        }${item.link ? `, '${item.link}' AS link` : ""};`
-      ),
-    ],
-  };
-}
-
-export function carouselSQL(component: Carousel): RenderedComponent<Carousel> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.images.map((image) =>
-        `SELECT '${image.src}' AS src${
-          image.alt ? `, '${image.alt}' AS alt` : ""
-        };`
-      ),
-    ],
-  };
-}
-
-export function chartSQL(component: Chart): RenderedComponent<Chart> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.type}' AS type;`,
-      ...component.data.map((point) =>
-        `SELECT ${
-          typeof point.x === "number" ? point.x : `'${point.x}'`
-        } AS x, ${point.y} AS y;`
-      ),
-    ],
-  };
-}
-
-export function codeSQL(component: Code): RenderedComponent<Code> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.language}' AS language, '${component.code}' AS code;`,
-    ],
-  };
-}
-
-export function cookieSQL(component: Cookie): RenderedComponent<Cookie> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.name}' AS name, '${component.value}' AS value${
-        component.path ? `, '${component.path}' AS path` : ""
-      }${component.expires ? `, '${component.expires}' AS expires` : ""};`,
-    ],
-  };
-}
-
-export function csvSQL(component: Csv): RenderedComponent<Csv> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.filename}' AS filename, ${
-        component.columns.map((col) => `'${col}'`).join(", ")
-      } AS columns;`,
-    ],
-  };
-}
-
-export function datagridSQL(component: DataGrid): RenderedComponent<DataGrid> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.items.map((item) =>
-        `SELECT '${item.name}' AS name, '${item.value}' AS value;`
-      ),
-    ],
-  };
-}
-
-export function debugSQL(component: Debug): RenderedComponent<Debug> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, ${
-        JSON.stringify(component.data)
-      } AS data;`,
-    ],
-  };
-}
-
-export function dividerSQL(component: Divider): RenderedComponent<Divider> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component${
-        component.style ? `, '${component.style}' AS style` : ""
-      };`,
-    ],
-  };
-}
-
-export function dynamicSQL(component: Dynamic): RenderedComponent<Dynamic> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.content}' AS content;`,
-    ],
-  };
-}
-
-export function formSQL(component: Form): RenderedComponent<Form> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.action}' AS action;`,
-      ...component.fields.map((field) => {
-        let fieldSQL =
-          `SELECT '${field.name}' AS name, '${field.type}' AS type`;
-        if (field.placeholder) {
-          fieldSQL += `, '${field.placeholder}' AS placeholder`;
-        }
-        if (field.required) fieldSQL += `, TRUE AS required`;
-        if (field.options) {
-          fieldSQL += `, '${field.options.join(", ")}' AS options`;
-        }
-        if (field.label) fieldSQL += `, '${field.label}' AS label`;
-        if (field.min !== undefined) fieldSQL += `, ${field.min} AS min`;
-        if (field.max !== undefined) fieldSQL += `, ${field.max} AS max`;
-        if (field.step !== undefined) fieldSQL += `, ${field.step} AS step`;
-        if (field.minlength !== undefined) {
-          fieldSQL += `, ${field.minlength} AS minlength`;
-        }
-        if (field.maxlength !== undefined) {
-          fieldSQL += `, ${field.maxlength} AS maxlength`;
-        }
-        if (field.pattern) fieldSQL += `, '${field.pattern}' AS pattern`;
-        if (field.autocomplete) {
-          fieldSQL += `, '${field.autocomplete}' AS autocomplete`;
-        }
-        if (field.autofocus) fieldSQL += `, TRUE AS autofocus`;
-        if (field.description) {
-          fieldSQL += `, '${field.description}' AS description`;
-        }
-        if (field.checked !== undefined) {
-          fieldSQL += `, ${field.checked} AS checked`;
-        }
-        return fieldSQL + ";";
-      }),
-    ],
-  };
-}
-
-export function heroSQL(component: Hero): RenderedComponent<Hero> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component${
-        component.description
-          ? `, '${component.description}' AS description`
-          : ""
-      }${component.image ? `, '${component.image}' AS image` : ""}${
-        component.link ? `, '${component.link}' AS link` : ""
-      }${component.linkText ? `, '${component.linkText}' AS linkText` : ""};`,
-    ],
-  };
-}
-
-export function htmlSQL(component: Html): RenderedComponent<Html> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.content}' AS content;`,
-    ],
-  };
-}
-
-export function httpHeaderSQL(
-  component: HttpHeader,
-): RenderedComponent<HttpHeader> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...Object.keys(component.headers).map((key) =>
-        `SELECT '${key}' AS name, '${component.headers[key]}' AS value;`
-      ),
-    ],
-  };
-}
-
-export function jsonSQL(component: Json): RenderedComponent<Json> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, ${
-        JSON.stringify(component.data)
-      } AS data;`,
-    ],
-  };
-}
-
-export function listSQL(component: List): RenderedComponent<List> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.items.map((item) => {
-        let itemSQL = `SELECT '${item.title}' AS title`;
-        if (item.link) itemSQL += `, '${item.link}' AS link`;
-        if (item.description) {
-          itemSQL += `, '${item.description}' AS description`;
-        }
-        if (item.icon) itemSQL += `, '${item.icon}' AS icon`;
-        if (item.active) itemSQL += `, TRUE AS active`;
-        if (item.color) itemSQL += `, '${item.color}' AS color`;
-        if (item.delete_link) {
-          itemSQL += `, '${item.delete_link}' AS delete_link`;
-        }
-        if (item.edit_link) itemSQL += `, '${item.edit_link}' AS edit_link`;
-        if (item.image_url) itemSQL += `, '${item.image_url}' AS image_url`;
-        if (item.view_link) itemSQL += `, '${item.view_link}' AS view_link`;
-        return itemSQL + ";";
-      }),
-    ],
-  };
-}
-
-export function mapSQL(component: Map): RenderedComponent<Map> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.markers.map((marker) =>
-        `SELECT ${marker.latitude} AS latitude, ${marker.longitude} AS longitude${
-          marker.label ? `, '${marker.label}' AS label` : ""
-        };`
-      ),
-    ],
-  };
-}
-
-export function redirectSQL(component: Redirect): RenderedComponent<Redirect> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.url}' AS url;`,
-    ],
-  };
-}
-
-export function rssSQL(component: Rss): RenderedComponent<Rss> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.url}' AS url${
-        component.title ? `, '${component.title}' AS title` : ""
-      }${
-        component.description
-          ? `, '${component.description}' AS description`
-          : ""
-      };`,
-    ],
-  };
-}
-
-export function shellSQL(component: Shell): RenderedComponent<Shell> {
-  let shellSQL = `SELECT '${component.component}' AS component`;
-  if (component.layout) shellSQL += `, '${component.layout}' AS layout`;
-  if (component.css) shellSQL += `, '${component.css}' AS css`;
-  if (component.favicon) shellSQL += `, '${component.favicon}' AS favicon`;
-  if (component.javascript) {
-    shellSQL += `, '${component.javascript}' AS javascript`;
-  }
-  if (component.language) shellSQL += `, '${component.language}' AS language`;
-  if (component.theme) shellSQL += `, '${component.theme}' AS theme`;
-  if (component.title) shellSQL += `, '${component.title}' AS title`;
-  if (component.description) {
-    shellSQL += `, '${component.description}' AS description`;
-  }
-  if (component.image) shellSQL += `, '${component.image}' AS image`;
-  if (component.manifest) shellSQL += `, '${component.manifest}' AS manifest`;
-  if (component.menu_item) {
-    if (typeof component.menu_item === "string") {
-      shellSQL += `, '${component.menu_item}' AS menu_item`;
-    } else {
-      shellSQL += `, '${component.menu_item.title}' AS menu_item_title, ${
-        component.menu_item.submenu.map((sub) =>
-          `'${sub.title}' AS title, '${sub.link}' AS link`
-        ).join(", ")
-      } AS submenu`;
-    }
-  }
-  if (component.norobot) shellSQL += `, TRUE AS norobot`;
-  if (component.refresh) shellSQL += `, ${component.refresh} AS refresh`;
-  if (component.rss) shellSQL += `, '${component.rss}' AS rss`;
-  if (component.search_target) {
-    shellSQL += `, '${component.search_target}' AS search_target`;
-  }
-  if (component.search_value) {
-    shellSQL += `, '${component.search_value}' AS search_value`;
-  }
-  if (component.social_image) {
-    shellSQL += `, '${component.social_image}' AS social_image`;
-  }
-  return { component, SQL: [shellSQL + ";"] };
-}
-
-export function stepsSQL(component: Steps): RenderedComponent<Steps> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.steps.map((step) =>
-        `SELECT '${step.label}' AS label, '${step.link}' AS link;`
-      ),
-    ],
-  };
-}
-
-export function tabSQL(component: Tab): RenderedComponent<Tab> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.tabs.map((tab) =>
-        `SELECT '${tab.label}' AS label, '${tab.link}' AS link${
-          tab.active ? `, TRUE AS active` : ""
-        };`
-      ),
-    ],
-  };
-}
-
-export function tableSQL(component: Table): RenderedComponent<Table> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component${
-        component.sort ? `, ${component.sort} AS sort` : ""
-      }${component.search ? `, ${component.search} AS search` : ""};`,
-      ...component.columns.map((column) =>
-        `'${column.name}'${column.label ? `, ' AS ${column.label}'` : ""};`
-      ),
-    ],
-  };
-}
-
-export function textSQL(component: Text): RenderedComponent<Text> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.content}' AS content;`,
-    ],
-  };
-}
-
-export function timelineSQL(component: Timeline): RenderedComponent<Timeline> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.events.map((event) =>
-        `SELECT '${event.timestamp}' AS timestamp, '${event.description}' AS description;`
-      ),
-    ],
-  };
-}
-
-export function titleSQL(component: Title): RenderedComponent<Title> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component, '${component.contents}' AS contents, ${
-        component.level ?? 1
-      } AS level;`,
-    ],
-  };
-}
-
-export function trackingSQL(component: Tracking): RenderedComponent<Tracking> {
-  return {
-    component,
-    SQL: [
-      `SELECT '${component.component}' AS component;`,
-      ...component.logs.map((log) =>
-        `SELECT '${log.timestamp}' AS timestamp, '${log.action}' AS action${
-          log.user ? `, '${log.user}' AS user` : ""
-        };`
-      ),
-    ],
-  };
-}
diff --git a/lib/sqlpage/mod.ts b/lib/sqlpage/mod.ts
deleted file mode 100644
index f058258a..00000000
--- a/lib/sqlpage/mod.ts
+++ /dev/null
@@ -1,3 +0,0 @@
-export * from "./component.ts";
-export * from "./render.ts";
-export * from "./sqlpage-aide.ts";
diff --git a/lib/sqlpage/mod_test.ts b/lib/sqlpage/mod_test.ts
deleted file mode 100644
index 832c4a0b..00000000
--- a/lib/sqlpage/mod_test.ts
+++ /dev/null
@@ -1,145 +0,0 @@
-import { assertEquals } from "https://deno.land/std@0.224.0/assert/assert_equals.ts";
-import { ComponentsRenderer, SQLPageAide } from "./mod.ts";
-
-Deno.test("SQLPageAide with SQL pages class", () => {
-  // Define a class with SQL methods
-  class MySqlPages {
-    nonUpsertSQL() {
-      return "-- this will not be part of upsert, just SQL";
-    }
-
-    "index.sql"() {
-      return "SELECT * FROM users;";
-    }
-
-    "page1.sql"() {
-      return "INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com');";
-    }
-  }
-
-  // by default SQLPageAide includes all "*.sql" methods as upsert SQL
-  // and we specify an extra method to include for general SQL
-  const sqlAide = new SQLPageAide(MySqlPages).includeSql("nonUpsertSQL");
-  const sqlStatements = sqlAide.SQL();
-
-  assertEquals(sqlStatements.length, 3);
-  assertEquals(
-    sqlStatements[0],
-    "-- this will not be part of upsert, just SQL",
-  );
-  assertEquals(
-    sqlStatements[1],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('index.sql', 'SELECT * FROM users;', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-  assertEquals(
-    sqlStatements[2],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('page1.sql', 'INSERT INTO users (name, email) VALUES (''John Doe'', ''john@example.com'');', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-});
-
-Deno.test("SQLPageAide with MySqlPages custom instance and custom args", () => {
-  // Define a class with SQL methods
-  class MySqlPages {
-    constructor(readonly cr: ComponentsRenderer) {
-    }
-    "index.sql"(user: string) {
-      return this.cr.component({
-        component: "alert",
-        message: `${user}`,
-      }).SQL();
-    }
-  }
-
-  // Define a contentsArgsSupplier function
-  const sqlPageAide = new SQLPageAide(new MySqlPages(new ComponentsRenderer()))
-    .withContentsArgsSupplier((_source, _path, user) => [user]);
-
-  const sqlStatements = sqlPageAide.SQL("John Doe");
-
-  assertEquals(sqlStatements.length, 1);
-  assertEquals(
-    sqlStatements[0],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('index.sql', 'SELECT ''alert'' AS component, ''John Doe'' AS message;', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-});
-
-Deno.test("SQLPageAide with SQL pages object and custom args", () => {
-  const sqlAide = new SQLPageAide({
-    "index.sql"() {
-      return "SELECT * FROM users;";
-    },
-    "page1.sql": (user: string, email: string) => {
-      return `INSERT INTO users (name, email) VALUES ('${user}', '${email}');`;
-    },
-  }).withContentsArgs(["John Doe", "john@example.com"]);
-
-  const sqlStatements = sqlAide.SQL();
-  assertEquals(sqlStatements.length, 2);
-  assertEquals(
-    sqlStatements[0],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('index.sql', 'SELECT * FROM users;', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-  assertEquals(
-    sqlStatements[1],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('page1.sql', 'INSERT INTO users (name, email) VALUES (''John Doe'', ''john@example.com'');', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-});
-
-Deno.test("SQLPageAide with SQL pages object and custom args", () => {
-  // this is a "special" test case to ensure the SQLPageAide works with SQLa instances
-  // without requiring SQLa as a dependency
-  interface SpecialSQL {
-    SQL: () => string;
-  }
-
-  function isSpecialSQL(instance: unknown): instance is SpecialSQL {
-    // deno-lint-ignore no-explicit-any
-    if (instance && typeof instance === "object" && (instance as any)["SQL"]) {
-      return true;
-    }
-    return false;
-  }
-
-  const sqlAide = new SQLPageAide({
-    "index.sql"() {
-      return "SELECT * FROM users;";
-    },
-    "page1.sql": (user: string, email: string) => {
-      return `INSERT INTO users (name, email) VALUES ('${user}', '${email}');`;
-    },
-    "page2.sql": (user: string, email: string) => {
-      return {
-        SQL: () =>
-          `INSERT INTO users (name, email) VALUES ('${user}', '${email}');`,
-      };
-    },
-    "page3.sql": () => {
-      return {
-        "shouldBeBad": "isBad",
-      };
-    },
-  })
-    .withContentsArgs(["John Doe", "john@example.com"])
-    .onNonStringUpsertContents((result) =>
-      isSpecialSQL(result) ? result.SQL() : `/* Bad result ${typeof result} */`
-    );
-
-  const sqlStatements = sqlAide.SQL();
-  assertEquals(sqlStatements.length, 4);
-  assertEquals(
-    sqlStatements[0],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('index.sql', 'SELECT * FROM users;', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-  assertEquals(
-    sqlStatements[1],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('page1.sql', 'INSERT INTO users (name, email) VALUES (''John Doe'', ''john@example.com'');', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-  assertEquals(
-    sqlStatements[2],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('page2.sql', 'INSERT INTO users (name, email) VALUES (''John Doe'', ''john@example.com'');', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-  assertEquals(
-    sqlStatements[3],
-    "INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('page3.sql', '/* Bad result object */', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;",
-  );
-});
diff --git a/lib/sqlpage/render.ts b/lib/sqlpage/render.ts
deleted file mode 100644
index cb3bfaba..00000000
--- a/lib/sqlpage/render.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-import * as c from "./component.ts";
-
-/**
- * Union type of all possible components
- */
-type SqlPageComponent =
-  | c.Alert
-  | c.Authentication
-  | c.Breadcrumb
-  | c.Button
-  | c.Card
-  | c.Carousel
-  | c.Chart
-  | c.Code
-  | c.Cookie
-  | c.Csv
-  | c.DataGrid
-  | c.Debug
-  | c.Divider
-  | c.Dynamic
-  | c.Form
-  | c.Hero
-  | c.Html
-  | c.HttpHeader
-  | c.Json
-  | c.List
-  | c.Map
-  | c.Redirect
-  | c.Rss
-  | c.Shell
-  | c.Steps
-  | c.Tab
-  | c.Table
-  | c.Text
-  | c.Timeline
-  | c.Title
-  | c.Tracking;
-
-export function component<Component extends SqlPageComponent>(
-  c: Component,
-): string | string[] {
-  const functionName = `${c.component}SQL`;
-  // deno-lint-ignore no-explicit-any
-  const renderComponentFn = (c as any)[functionName];
-
-  if (typeof renderComponentFn === "function") {
-    const result = renderComponentFn(c);
-    if (typeof result === "object" && result.SQL) {
-      const candidate = result.SQL;
-      if (typeof candidate === "string") {
-        return candidate as string;
-      } else if (typeof candidate === "function") {
-        return candidate();
-      } else if (Array.isArray(candidate)) {
-        return candidate as string[];
-      } else {
-        return String(candidate);
-      }
-    }
-    return `/* '${functionName}' returned invalid result type '${typeof result}' in ComponentRenderer.SQL() */`;
-  } else {
-    return `/* no '${functionName}' found for component '${c.component}' in ComponentRenderer.SQL() */`;
-  }
-}
-
-/**
- * ComponentRenderer is responsible for rendering SQL statements based on the given components.
- * It dynamically calls SQL generation functions for each component type.
- */
-export class ComponentsRenderer {
-  private components: SqlPageComponent[] = [];
-
-  /**
-   * Adds components to the renderer.
-   *
-   * @param components - The components to be rendered. These components should match the interface expected by SQL generator functions.
-   * @returns The instance of ComponentRenderer for method chaining.
-   */
-  component<C extends SqlPageComponent>(...components: C[]): this {
-    this.components.push(...components);
-    return this;
-  }
-
-  /**
-   * Generates SQL for all added components by dynamically calling the appropriate
-   * SQL generation function called `componentXyzSQL()` in the ./components.ts module.
-   * If a function corresponding to a component type is not found, it returns a
-   * default SQL comment indicating the missing function.
-   *
-   * @returns A string containing all the generated SQL statements, joined by newline characters.
-   */
-  SQL(): string {
-    return this.components.flatMap((component) => {
-      const functionName = `${component.component}SQL`;
-      // deno-lint-ignore no-explicit-any
-      const renderComponentFn = (c as any)[functionName];
-
-      if (typeof renderComponentFn === "function") {
-        const result = renderComponentFn(component);
-        if (typeof result === "object" && result.SQL) {
-          const candidate = result.SQL;
-          if (typeof candidate === "string") {
-            return candidate as string;
-          } else if (typeof candidate === "function") {
-            return candidate();
-          } else if (Array.isArray(candidate)) {
-            return candidate as string[];
-          }
-        }
-        return renderComponentFn(component);
-      } else {
-        return {
-          component,
-          SQL:
-            `/* no '${functionName}' found for component '${component.component}' in ComponentRenderer.SQL() */`,
-        };
-      }
-    }).join("\n");
-  }
-}
diff --git a/lib/sqlpage/sqlpage-aide.ts b/lib/sqlpage/sqlpage-aide.ts
deleted file mode 100644
index 54239f69..00000000
--- a/lib/sqlpage/sqlpage-aide.ts
+++ /dev/null
@@ -1,649 +0,0 @@
-// deno-lint-ignore no-explicit-any
-type Any = any;
-
-/**
- * Interface which accepts a Source class or object and limits the keys to
- * just functions that return strings. If the Source class or object has
- * other properties that are not functions those will be kept out of the
- * type-safe shape.
- */
-export type TextSuppliers<Source> = {
-  [K in keyof Source]: K extends string ? (
-      Source[K] extends (...args: Any[]) => string | string[] ? K : never
-    )
-    : never;
-};
-
-export type TextSupplierFnNames<Source> = TextSuppliers<Source>[keyof Source];
-
-export function textSupplierFnNames<Source>(
-  instance: Source,
-  isClass: boolean,
-): TextSupplierFnNames<Source>[] {
-  const propertyNames = Object.getOwnPropertyNames(
-    instance,
-  ) as (keyof Source)[];
-
-  // Filter property names based on the type of their corresponding values
-  const supplierNames = propertyNames.filter((name) => {
-    if (isClass && name == "constructor") return false;
-
-    const potentialFn = instance[name];
-    if (typeof potentialFn === "function") {
-      // we cannot reflect the actual return type of the function right now
-      return true;
-    }
-
-    return false;
-  });
-
-  return supplierNames as TextSupplierFnNames<Source>[];
-}
-
-/**
- * Represents the structure of a SQL page file with path and content.
- */
-export interface SqlPagesFileRecord<Source> {
-  /** The identifier or name of the SQL page method. */
-  readonly path: string;
-  /** The SQL content generated by the method. */
-  readonly content: string;
-  /** where the SPFR was generated from */
-  readonly source: SourcePaths<Source>;
-  /** the method that generated the content */
-  readonly method: TextSupplierFnNames<Source>;
-}
-
-/**
- * Defines the type for patterns used to match method names.
- * Can be a string or a RegExp.
- */
-export type PathPattern = string | RegExp;
-
-/**
- * A source and its paths (usually methods or functions that generate SQL).
- */
-export interface SourcePaths<T> {
-  readonly instance: T;
-  readonly paths: TextSupplierFnNames<T>[];
-  readonly class?: Any;
-}
-
-/**
- * A function type that determines which methods to process based on the PagesSrc instance and patterns.
- */
-export interface PathContentsSupplier<Source> {
-  (
-    sp: SourcePaths<Source>,
-    includePatterns: PathPattern[],
-    excludePatterns: PathPattern[],
-  ): TextSupplierFnNames<Source>[];
-}
-
-/**
- * A function type that supplies content arguments to SQL methods.
- */
-export interface ContentsArgsSupplier<
-  Source,
-  CandidateContentArgs extends Any[],
-  ContentArgs extends Any[],
-> {
-  (
-    sp: SourcePaths<Source>,
-    sqlPagePath: string,
-    ...candidateArgs: CandidateContentArgs
-  ): ContentArgs;
-}
-
-/**
- * A function type that supplies a SQL handler when a SQL method returns something
- * other than a string or string[]
- */
-export interface UnknownContentsTypeHandler<
-  Source,
-  ContentArgs extends Any[],
-> {
-  (
-    contentsResult: unknown,
-    sp: SourcePaths<Source>,
-    sqlPagePath: string,
-    args?: ContentArgs,
-  ): string;
-}
-
-export function sourcePaths<T>(candidate: Any, ...args: Any[]): SourcePaths<T> {
-  if (typeof candidate === "object") {
-    const isClassInstance = candidate.constructor &&
-      candidate.constructor !== Object;
-    const instanceOf = isClassInstance ? candidate.constructor : undefined;
-    return {
-      class: instanceOf,
-      instance: candidate as T,
-      paths: instanceOf
-        ? textSupplierFnNames<T>(instanceOf.prototype, true)
-        : textSupplierFnNames<T>(candidate, false),
-    };
-  }
-
-  if (typeof candidate === "function" && candidate.prototype) {
-    const instance = new candidate(...args) as T;
-    return {
-      class: candidate,
-      instance,
-      paths: textSupplierFnNames<T>(candidate.prototype, true),
-    };
-  }
-
-  if (typeof candidate === "function") {
-    return sourcePaths(candidate(...args), ...args);
-  }
-
-  throw new Error(
-    "Invalid input: candidate must be an object, class definition, or constructor function",
-  );
-}
-
-/**
- * SQLPageAide is a utility class designed to facilitate the creation of upsert statements
- * for the SQLPage low-code tool. SQLPage expects a table called `sqlpage_files` with
- * columns `path` and `contents` to define pages that it can serve via HTTP.
- *
- * The `path` column serves as a unique identifier for each page or API endpoint, while the
- * `contents` column holds the SQL statements or other content that define the page's response.
- *
- * SQLPageAide enables developers to use strongly-typed TypeScript objects and classes to
- * define these paths and contents more conveniently and with fewer errors.
- *
- * Key Features:
- * - Structured Definitions: Use TypeScript classes or objects to define SQL page paths and contents.
- * - Strong Typing: Leverage TypeScript's strong typing for consistent and accurate data types and method signatures.
- * - Convenience Functions:
- *   - `sources()`: Specify the classes or objects containing SQL definitions.
- *   - `include()`: Include specific patterns to match method names.
- *   - `exclude()`: Exclude specific patterns from matching method names.
- *   - `withContentsArgs()`: Inject additional context or arguments into SQL methods for dynamic content.
- *   - `pathContents()`: Customize the method selection process for upserting into `sqlpage_files`.
- * - Automatic Upsert Generation:
- *   - `upsertValues()`: Collects and prepares SQL statements for insertion or update.
- *   - `SQL()`: Generates SQL statements to manage entries in the `sqlpage_files` table.
- *
- * Benefits:
- * - Reduced Errors: Catch errors at compile-time with TypeScript, enhancing application robustness.
- * - Easier Maintenance: Structured SQL page definitions improve codebase readability and maintainability.
- * - Flexibility and Control: Full control over SQL page definition and management, with customizable method selection.
- *
- * ## Usage Example
- *
- * ```typescript
- * // Define a class with SQL methods
- * class MySqlPages {
- *     "index.sql"() {
- *         return "SELECT * FROM users;";
- *     }
- *
- *     "page1.sql"() {
- *         return "INSERT INTO users (name, email) VALUES ('John Doe', 'john@example.com');";
- *     }
- * }
- *
- * // Generate SQL statements
- * console.log(new SQLPageAide(MySqlPages).SQL());
- * // Output:
- * // INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('index.sql', 'SELECT * FROM users;', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents=excluded.contents, last_modified=CURRENT_TIMESTAMP);
- * // INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('page1.sql', 'INSERT INTO users (name, email) VALUES (''John Doe'', ''john@example.com'');', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents=excluded.contents, last_modified=CURRENT_TIMESTAMP);
- * ```
- */
-export class SQLPageAide<
-  Source,
-  CandidateContentArgs extends Any[],
-  ContentArgs extends Any[],
-  SPFR extends SqlPagesFileRecord<Source>,
-> {
-  protected formattedSQL = false;
-  protected sqlPagesSources: SourcePaths<Source>[] = [];
-  protected upsertIncludePatterns: PathPattern[] = [];
-  protected upsertExcludePatterns: PathPattern[] = [];
-  protected sqlIncludePatterns: PathPattern[] = [];
-  protected sqlExcludePatterns: PathPattern[] = [];
-  protected contentsArgsSupplier?: ContentsArgsSupplier<
-    Source,
-    CandidateContentArgs,
-    ContentArgs
-  >;
-  protected defaultContentsArgs?: ContentArgs;
-  protected constructSPFR?: (
-    init: Pick<SqlPagesFileRecord<Source>, "path" | "content">,
-    method: TextSupplierFnNames<Source>,
-    sp: SourcePaths<Source>,
-  ) => SPFR;
-  protected refineSPFR?: (value: SPFR, index: number, array: SPFR[]) => SPFR;
-  protected unknownUpsertContentsTypeHandler?: UnknownContentsTypeHandler<
-    Source,
-    ContentArgs
-  >;
-  protected unknownSqlStmtTypeHandler?: UnknownContentsTypeHandler<
-    Source,
-    ContentArgs
-  >;
-  protected sqlStmtsSupplier: PathContentsSupplier<Source> = (
-    sp,
-    includePatterns,
-    excludePatterns,
-  ) => {
-    return sp.paths.filter((name) => {
-      const matchesInclude = includePatterns.some((pattern) =>
-        typeof pattern === "string"
-          ? name.includes(pattern)
-          : pattern.test(name)
-      );
-      const matchesExclude = excludePatterns.some((pattern) =>
-        typeof pattern === "string"
-          ? name.includes(pattern)
-          : pattern.test(name)
-      );
-      return matchesInclude && !matchesExclude;
-    });
-  };
-  protected upsertPathContentsSupplier: PathContentsSupplier<Source> = (
-    sp,
-    includePatterns,
-    excludePatterns,
-  ) => {
-    return sp.paths.filter((name) => {
-      const matchesInclude = includePatterns.some((pattern) =>
-        typeof pattern === "string"
-          ? name.includes(pattern)
-          : pattern.test(name)
-      );
-      const matchesExclude = excludePatterns.some((pattern) =>
-        typeof pattern === "string"
-          ? name.includes(pattern)
-          : pattern.test(name)
-      );
-      return matchesInclude && !matchesExclude;
-    });
-  };
-
-  /**
-   * Creates an instance of SQLPageAide.
-   * @param defaultSqlPagesSources - The default SQL pages classes or objects.
-   */
-  constructor(...defaultSqlPagesSources: Source[]) {
-    this.sources(...defaultSqlPagesSources);
-  }
-
-  emitformattedSQL(formatted = true) {
-    this.formattedSQL = formatted;
-    return this;
-  }
-
-  /**
-   * Adds SQL pages classes or objects to the instance.
-   * If a source is a class (constructor function), it will be instantiated before being added.
-   * New sources are appended to the existing list.
-   * @param sources - The SQL pages classes or objects.
-   * @returns The SQLPageAide instance.
-   */
-  sources(...sources: Source[]): this {
-    this.sqlPagesSources.push(...sources.map((s) => sourcePaths<Source>(s)));
-    return this;
-  }
-
-  /**
-   * Includes specific patterns to match method names which will be upserted
-   * into sqlpage_files table.
-   * If no patterns are provided, all methods will be considered.
-   * @param patterns - The patterns to include method names.
-   * @returns The SQLPageAide instance.
-   */
-  includeUpserts(...patterns: PathPattern[]): this {
-    this.upsertIncludePatterns = patterns;
-    return this;
-  }
-
-  /**
-   * Excludes specific patterns from matching method names whose function results
-   * will be upserted into sqlpage_files table.
-   * @param patterns - The patterns to exclude method names.
-   * @returns The SQLPageAide instance.
-   */
-  excludeUpserts(...patterns: PathPattern[]): this {
-    this.upsertExcludePatterns = patterns;
-    return this;
-  }
-
-  /**
-   * Includes specific patterns to match method names which will be injected
-   * as SQL before upserting into sqlpage_files.
-   * If no patterns are provided, all methods will be considered.
-   * @param patterns - The patterns to include method names.
-   * @returns The SQLPageAide instance.
-   */
-  includeSql(...patterns: PathPattern[]): this {
-    this.sqlIncludePatterns = patterns;
-    return this;
-  }
-
-  /**
-   * Excludes specific patterns to match method names which will be injected
-   * as SQL before upserting into sqlpage_files.
-   * @param patterns - The patterns to exclude method names.
-   * @returns The SQLPageAide instance.
-   */
-  excludeSql(...patterns: PathPattern[]): this {
-    this.sqlExcludePatterns = patterns;
-    return this;
-  }
-  /**
-   * Sets the default contents arguments passed to each SQL Method.
-   * @param contentsArgs - The contents arguments supplier function.
-   * @returns The SQLPageAide instance.
-   */
-  withContentsArgs(contentsArgs?: ContentArgs): this {
-    this.defaultContentsArgs = contentsArgs;
-    return this;
-  }
-
-  /**
-   * Sets the contents arguments supplier function and its arguments.
-   * The contents arguments supplier provides additional arguments to the SQL methods.
-   * @param contentsArgsSupplier - The contents arguments supplier function.
-   * @returns The SQLPageAide instance.
-   */
-  withContentsArgsSupplier(
-    contentsArgsSupplier: ContentsArgsSupplier<
-      Source,
-      CandidateContentArgs,
-      ContentArgs
-    >,
-  ): this {
-    this.contentsArgsSupplier = contentsArgsSupplier;
-    return this;
-  }
-
-  /**
-   * Sets the contents handler function if the SQL methods return non-string result.
-   * @param handler - The contents arguments supplier function.
-   * @param contentsArgs - The arguments for the contents supplier.
-   * @returns The SQLPageAide instance.
-   */
-  onNonStringUpsertContents(
-    handler: UnknownContentsTypeHandler<Source, ContentArgs>,
-  ): this {
-    this.unknownUpsertContentsTypeHandler = handler;
-    return this;
-  }
-
-  /**
-   * Sets the contents handler function if the SQL methods return non-string result.
-   * @param handler - The contents arguments supplier function.
-   * @param contentsArgs - The arguments for the contents supplier.
-   * @returns The SQLPageAide instance.
-   */
-  onNonStringSqlStmt(
-    handler: UnknownContentsTypeHandler<Source, ContentArgs>,
-  ): this {
-    this.unknownSqlStmtTypeHandler = handler;
-    return this;
-  }
-
-  /**
-   * Sets the supplier function that determines which methods to process for
-   * providing upsert SQL contents.
-   * @param pathContentsSupplier - The supplier function for selecting methods.
-   * @returns The SQLPageAide instance.
-   */
-  upsertPathContents(pathContentsSupplier: PathContentsSupplier<Source>): this {
-    this.upsertPathContentsSupplier = pathContentsSupplier;
-    return this;
-  }
-
-  /**
-   * Sets the function which can take the components of an initial SqlPageFileRecord
-   * and construct a special type-safe version.
-   * @param spfrConstructor the constructor used by upsertFiles()
-   */
-  withSqlPagesFileRecordConstructor(
-    spfrConstructor?: SQLPageAide<
-      Source,
-      CandidateContentArgs,
-      ContentArgs,
-      SPFR
-    >["constructSPFR"],
-  ) {
-    this.constructSPFR = spfrConstructor;
-    return this;
-  }
-
-  /**
-   * Sets the supplier function which can transform or "refine" a SqlPageFileRecord
-   * before its SQL is emitted. This method allows modification of the content by
-   * returning a replacement for any given SqlPagesFileRecord (SPFR).
-   * @param spfrTransfomer the upsertFiles.map() transformer function
-   */
-  withSqlPagesFileRecordTransformer(
-    spfrTransfomer?: SQLPageAide<
-      Source,
-      CandidateContentArgs,
-      ContentArgs,
-      SPFR
-    >["refineSPFR"],
-  ) {
-    this.refineSPFR = spfrTransfomer;
-    return this;
-  }
-
-  /**
-   * Sets the supplier function that determines which methods to process for
-   * SQL statements before upserting into sqlpage_files.
-   * @param sqlStmtsSupplier - The supplier function for selecting methods.
-   * @returns The SQLPageAide instance.
-   */
-  sqlStatementsSupplier(sqlStmtsSupplier: PathContentsSupplier<Source>): this {
-    this.sqlStmtsSupplier = sqlStmtsSupplier;
-    return this;
-  }
-
-  /**
-   * Executes the given path content function, handling the context and arguments.
-   * @param source - The source object or class instance containing the method.
-   * @param method - The name of the method to call.
-   * @param args - The arguments to pass to the method.
-   * @returns The SQL result returned by the method (usually string or string[]).
-   */
-  protected execPathContentsFn(
-    sp: SourcePaths<Source>,
-    method: TextSupplierFnNames<Source>,
-    args?: ContentArgs,
-  ) {
-    const { instance } = sp;
-    if (
-      instance &&
-      typeof instance === "object" &&
-      typeof (instance as Any)[method] === "function"
-    ) {
-      const fn = (instance as Any)[method] as (...args: Any[]) => unknown;
-      return sp.class
-        ? (fn.apply(instance, args ? args : []))
-        : (args ? fn(...args) : fn());
-    }
-    return `Method '${String(method)}' not found in source ${instance}`;
-  }
-
-  /**
-   * Collects all matching SQL statements from the specified methods.
-   * The methods are selected based on the provided include and exclude patterns
-   * and the PathContentsSupplier function.
-   * If no patterns are provided, no methods in the source are processed.
-   *
-   * @param args - The arguments to pass to the contents arguments supplier and SQL methods.
-   * @returns An array of SQL page files, each containing a path and content.
-   */
-  sqlStmts(...args: CandidateContentArgs): string[] {
-    const sqlStmts: string[] = [];
-
-    for (const source of this.sqlPagesSources) {
-      const methods = this.sqlStmtsSupplier(
-        source,
-        this.sqlIncludePatterns,
-        this.sqlExcludePatterns,
-      );
-
-      for (const method of methods) {
-        let sqlStatement: unknown;
-
-        if (this.contentsArgsSupplier) {
-          sqlStatement = this.execPathContentsFn(
-            source,
-            method,
-            this.contentsArgsSupplier(source, method, ...args),
-          );
-        } else {
-          sqlStatement = this.execPathContentsFn(
-            source,
-            method,
-            this.defaultContentsArgs,
-          );
-        }
-
-        if (typeof sqlStatement === "string") {
-          sqlStmts.push(sqlStatement);
-        } else if (Array.isArray(sqlStatement)) {
-          sqlStmts.push(sqlStatement.join("\n"));
-        } else if (this.unknownSqlStmtTypeHandler) {
-          const ucthArgs = this.contentsArgsSupplier
-            ? this.contentsArgsSupplier(source, method, ...args)
-            : this.defaultContentsArgs;
-          sqlStmts.push(this.unknownSqlStmtTypeHandler(
-            sqlStatement,
-            source,
-            method,
-            ucthArgs,
-          ));
-        } else {
-          sqlStmts.push(
-            `\n/* '${method}' in '${
-              String(source.instance)
-            }' returned type ${typeof sqlStatement} instead of string or string[] */`,
-          );
-        }
-      }
-    }
-
-    return sqlStmts;
-  }
-
-  /**
-   * Collects all matching SQL statements from the specified methods in the sources.
-   * The methods are selected based on the provided include and exclude patterns
-   * and the PathContentsSupplier function.
-   *
-   * If no patterns are provided, all methods that look like "*.sql"() in the source
-   * are processed.
-   *
-   * @param args - The arguments to pass to the contents arguments supplier and SQL methods.
-   * @returns An array of SQL page files, each containing a path and content.
-   */
-  upsertValues(...args: CandidateContentArgs): SPFR[] {
-    const constructSPFR = this.constructSPFR ??
-      ((init, method, source) => ({ ...init, method, source } as SPFR));
-    const upsertFiles: SPFR[] = [];
-
-    for (const source of this.sqlPagesSources) {
-      const methods = this.upsertPathContentsSupplier(
-        source,
-        this.upsertIncludePatterns.length == 0
-          ? [/.sql$/]
-          : this.upsertIncludePatterns,
-        this.upsertExcludePatterns,
-      );
-
-      for (const method of methods) {
-        let sqlStatement: unknown;
-
-        if (this.contentsArgsSupplier) {
-          sqlStatement = this.execPathContentsFn(
-            source,
-            method,
-            this.contentsArgsSupplier(source, method, ...args),
-          );
-        } else {
-          sqlStatement = this.execPathContentsFn(
-            source,
-            method,
-            this.defaultContentsArgs,
-          );
-        }
-
-        if (typeof sqlStatement === "string") {
-          upsertFiles.push(
-            constructSPFR(
-              { path: method, content: sqlStatement },
-              method,
-              source,
-            ),
-          );
-        } else if (Array.isArray(sqlStatement)) {
-          upsertFiles.push(
-            constructSPFR(
-              { path: method, content: sqlStatement.join("\n") },
-              method,
-              source,
-            ),
-          );
-        } else if (this.unknownUpsertContentsTypeHandler) {
-          const ucthArgs = this.contentsArgsSupplier
-            ? this.contentsArgsSupplier(source, method, ...args)
-            : this.defaultContentsArgs;
-          upsertFiles.push(constructSPFR(
-            {
-              path: method,
-              content: this.unknownUpsertContentsTypeHandler(
-                sqlStatement,
-                source,
-                method,
-                ucthArgs,
-              ),
-            },
-            method,
-            source,
-          ));
-        } else {
-          upsertFiles.push(constructSPFR(
-            {
-              path: method,
-              content: `\n/* '${method}' in '${
-                String(source.instance)
-              }' returned type ${typeof sqlStatement} instead of string or string[] */`,
-            },
-            method,
-            source,
-          ));
-        }
-      }
-    }
-
-    // return the refined content or original
-    return this.refineSPFR ? upsertFiles.map(this.refineSPFR) : upsertFiles;
-  }
-
-  /**
-   * Generates SQL statements for upserting into the `sqlpage_files` table.
-   * Each SQL statement is a string in an array, representing an individual SQL upsert statement.
-   * @param args - The arguments to pass to the contents arguments supplier and SQL methods.
-   * @returns An array of SQL statements.
-   */
-  SQL(...args: CandidateContentArgs): string[] {
-    const upsertFiles = this.upsertValues(...args);
-    return [
-      ...this.sqlStmts(...args),
-      ...upsertFiles.map(({ path, content }) => {
-        const escapedPath = path.replace(/'/g, "''");
-        const escapedContent = content.replace(/'/g, "''");
-        return this.formattedSQL == false
-          ? `INSERT INTO sqlpage_files (path, contents, last_modified) VALUES ('${escapedPath}', '${escapedContent}', CURRENT_TIMESTAMP) ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;`
-          : `INSERT INTO sqlpage_files (path, contents, last_modified) VALUES (\n      '${escapedPath}',\n      '${escapedContent}',\n      CURRENT_TIMESTAMP)\n  ON CONFLICT(path) DO UPDATE SET contents = EXCLUDED.contents, last_modified = CURRENT_TIMESTAMP;`;
-      }),
-    ];
-  }
-}