create-monolayer-app 0.1.2 → 0.2.1

package/template/vendor/kysely-dsql/dsql/compatibility-rules.ts

@@ -0,0 +1,235 @@
+import type { DSQLValidationCode } from "./query-validation.js";
+
+export interface CompatibilityRule {
+  readonly code: DSQLValidationCode;
+  readonly feature: string;
+  readonly message: string;
+  readonly documentationUrl: string;
+  readonly check: (normalizedSql: string) => boolean;
+}
+
+const DOC_BASE = "https://docs.aws.amazon.com/aurora-dsql/latest/userguide";
+const DOC_FEATURES = `${DOC_BASE}/working-with-postgresql-compatibility-supported-sql-features.html`;
+const DOC_CREATE_TABLE = `${DOC_BASE}/create-table-syntax-support.html`;
+const DOC_ALTER_TABLE = `${DOC_BASE}/alter-table-syntax-support.html`;
+const DOC_INDEX = `${DOC_BASE}/working-with-create-index-async.html`;
+
+const isSynchronousIndex = (sql: string): boolean => {
+  if (!/\bcreate\s+(?:unique\s+)?index\b/u.test(sql)) {
+    return false;
+  }
+  return !/\bcreate\s+(?:unique\s+)?index\s+(?:if\s+not\s+exists\s+async|async(?:\s+if\s+not\s+exists)?)\b/u.test(
+    sql
+  );
+};
+
+const hasUnsupportedIndexClause = (sql: string): boolean => {
+  if (!/\bcreate\s+(?:unique\s+)?index\b/u.test(sql)) {
+    return false;
+  }
+  return /\busing\s+\w+|\bwhere\s+|\([^)]*\b(?:asc|desc)\b|\bnulls\s+(?:first|last)\b/u.test(
+    sql
+  );
+};
+
+const isAlterAddColumnWithConstraint = (sql: string): boolean => {
+  if (!/\balter\s+table\b/u.test(sql)) {
+    return false;
+  }
+  if (
+    /\balter\s+table\s+\S+\s+add\s+column\s+(?:if\s+not\s+exists\s+)?\S+\s+\S+\s+(?:default\b|not\s+null\b|primary\s+key\b|unique\b|references\b|check\b|generated\b)/u.test(
+      sql
+    )
+  ) {
+    return true;
+  }
+  return /\balter\s+table\s+\S+\s+add\s+(?!column\b|constraint\b|check\b|primary\s+key\b|unique\b|foreign\s+key\b)(?:if\s+not\s+exists\s+)?\S+\s+\S+\s+(?:default\b|not\s+null\b|primary\s+key\b|unique\b|references\b|check\b|generated\b)/u.test(
+    sql
+  );
+};
+
+const isCreateTableAs = (sql: string): boolean => {
+  if (/\bcreate\s+table\s+\S+\s+as\b/u.test(sql)) {
+    return true;
+  }
+  return /\bselect\s+.*\binto\s+(?:temporary\s+|temp\s+|unlogged\s+)?(?:table\s+)?\S+\s+from\b/u.test(
+    sql
+  );
+};
+
+export const COMPATIBILITY_RULES: readonly CompatibilityRule[] = [
+  {
+    code: "foreign_key",
+    feature: "Foreign key constraints",
+    message: "Aurora DSQL does not support foreign key constraints.",
+    documentationUrl: DOC_CREATE_TABLE,
+    check: (sql) => /\bforeign\s+key\b|\breferences\b/u.test(sql),
+  },
+  {
+    code: "trigger",
+    feature: "Triggers",
+    message: "Aurora DSQL does not support triggers.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) =>
+      /\b(?:create|alter|drop)\s+(?:or\s+replace\s+)?trigger\b/u.test(sql),
+  },
+  {
+    code: "function_language",
+    feature: "User-defined functions",
+    message:
+      "Aurora DSQL does not support user-defined functions or procedural languages.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) =>
+      /\b(?:create|alter|drop)\s+(?:or\s+replace\s+)?function\b/u.test(sql),
+  },
+  {
+    code: "procedure",
+    feature: "Stored procedures",
+    message: "Aurora DSQL does not support stored procedures.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) =>
+      /\b(?:create|alter|drop)\s+(?:or\s+replace\s+)?procedure\b/u.test(sql),
+  },
+  {
+    code: "truncate",
+    feature: "Table truncation",
+    message: "Aurora DSQL does not support TRUNCATE. Use DELETE FROM instead.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) => /\btruncate\b/u.test(sql),
+  },
+  {
+    code: "listen_notify",
+    feature: "LISTEN and NOTIFY",
+    message: "Aurora DSQL does not support LISTEN, NOTIFY, or UNLISTEN.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) => /\b(?:listen|notify|unlisten)\b/u.test(sql),
+  },
+  {
+    code: "extension",
+    feature: "PostgreSQL extensions",
+    message: "Aurora DSQL does not support CREATE EXTENSION or DROP EXTENSION.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) => /\b(?:create|drop)\s+extension\b/u.test(sql),
+  },
+  {
+    code: "postgres_type",
+    feature: "User-defined types and domains",
+    message: "Aurora DSQL does not support user-defined types or domains.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) => /\b(?:create|alter|drop)\s+(?:type|domain)\b/u.test(sql),
+  },
+  {
+    code: "temporary_object",
+    feature: "Temporary and unlogged objects",
+    message:
+      "Aurora DSQL does not support temporary or unlogged tables, views, or sequences.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) =>
+      /\bcreate\s+(?:global\s+|local\s+)?(?:temporary|temp|unlogged)\b|\b(?:temporary|temp|unlogged)\s+(?:table|view|sequence)\b/u.test(
+        sql
+      ),
+  },
+  {
+    code: "materialized_view",
+    feature: "Materialized views",
+    message: "Aurora DSQL does not support materialized views.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) => /\bmaterialized\s+view\b/u.test(sql),
+  },
+  {
+    code: "row_level_security",
+    feature: "Row-level security",
+    message:
+      "Aurora DSQL does not support row-level security or security policies.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) =>
+      /\brow\s+level\s+security\b|\b(?:create|alter|drop)\s+policy\b/u.test(
+        sql
+      ),
+  },
+  {
+    code: "database_or_tablespace",
+    feature: "Database and tablespace management",
+    message:
+      "Aurora DSQL does not support database or tablespace management statements.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) =>
+      /\b(?:create|alter|drop)\s+(?:database|tablespace)\b/u.test(sql),
+  },
+  {
+    code: "synchronous_index",
+    feature: "Synchronous index creation",
+    message:
+      "Aurora DSQL requires CREATE INDEX ASYNC for all index creation statements.",
+    documentationUrl: DOC_INDEX,
+    check: isSynchronousIndex,
+  },
+  {
+    code: "unsupported_index_clause",
+    feature: "Unsupported index clauses",
+    message:
+      "Aurora DSQL indexes do not support USING clauses, WHERE predicates, expressions, or sort ordering.",
+    documentationUrl: DOC_INDEX,
+    check: hasUnsupportedIndexClause,
+  },
+  {
+    code: "alter_column_type",
+    feature: "Altering column types",
+    message: "Aurora DSQL does not support altering column types.",
+    documentationUrl: DOC_ALTER_TABLE,
+    check: (sql) =>
+      /\balter\s+table\b.*\balter\s+(?:column\s+)?\S+\s+(?:set\s+data\s+)?type\b|\balter\s+column\s+\S+\s+(?:set\s+data\s+)?type\b/u.test(
+        sql
+      ),
+  },
+  {
+    code: "alter_column_set_not_null",
+    feature: "Setting NOT NULL on existing columns",
+    message: "Aurora DSQL does not support ALTER COLUMN SET NOT NULL.",
+    documentationUrl: DOC_ALTER_TABLE,
+    check: (sql) =>
+      /\balter\s+table\b.*\balter\s+(?:column\s+)?\S+\s+set\s+not\s+null\b|\balter\s+column\s+\S+\s+set\s+not\s+null\b/u.test(
+        sql
+      ),
+  },
+  {
+    code: "alter_add_column_constraint",
+    feature: "Adding column constraints during ALTER TABLE",
+    message:
+      "Aurora DSQL does not support inline constraints, defaults, or generated expressions when adding columns.",
+    documentationUrl: DOC_ALTER_TABLE,
+    check: isAlterAddColumnWithConstraint,
+  },
+  {
+    code: "create_table_as",
+    feature: "CREATE TABLE AS",
+    message: "Aurora DSQL does not support CREATE TABLE AS or SELECT INTO.",
+    documentationUrl: DOC_CREATE_TABLE,
+    check: isCreateTableAs,
+  },
+  {
+    code: "merge",
+    feature: "MERGE statements",
+    message:
+      "Aurora DSQL does not support MERGE statements. Use INSERT ... ON CONFLICT instead.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) => /\bmerge\b/u.test(sql),
+  },
+  {
+    code: "collation",
+    feature: "Collations",
+    message:
+      "Aurora DSQL does not support custom collations or COLLATE clauses.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) =>
+      /\bcollate\b|\b(?:create|alter|drop)\s+collation\b/u.test(sql),
+  },
+  {
+    code: "vacuum",
+    feature: "VACUUM and ANALYZE",
+    message:
+      "Aurora DSQL manages storage automatically and does not support VACUUM or ANALYZE statements.",
+    documentationUrl: DOC_FEATURES,
+    check: (sql) => /\bvacuum\b|\banalyze\b/u.test(sql),
+  },
+];

package/template/vendor/kysely-dsql/dsql/create-column-builder.ts

@@ -0,0 +1,187 @@
+import { ColumnDefinitionBuilder } from "kysely";
+
+/**
+ * Lists the Kysely data type strings that Aurora DSQL accepts for new columns.
+ *
+ * The TypeScript compiler accepts supported type names and parameter syntax.
+ * Numeric bounds are outside the type contract.
+ * Aurora DSQL supports precision up to 38 and scale up to 37.
+ * Aurora DSQL applies stored-value limits during `INSERT` and `UPDATE`.
+ *
+ * @example
+ * ```ts
+ * const columnType: DSQLColumnDataType = "numeric(38, 37)";
+ * ```
+ */
+export type DSQLColumnDataType =
+  | "bigint"
+  | "boolean"
+  | "bytea"
+  | "char"
+  | `char(${number})`
+  | "date"
+  | "decimal"
+  | `decimal(${number}, ${number})`
+  | "double precision"
+  | "float4"
+  | "float8"
+  | "int2"
+  | "int4"
+  | "int8"
+  | "integer"
+  | "json"
+  | "jsonb"
+  | "numeric"
+  | `numeric(${number}, ${number})`
+  | "real"
+  | "smallint"
+  | "text"
+  | "time"
+  | `time(${number})`
+  | "timestamp"
+  | `timestamp(${number})`
+  | "timestamptz"
+  | `timestamptz(${number})`
+  | "timetz"
+  | `timetz(${number})`
+  | "uuid"
+  | "varchar"
+  | `varchar(${number})`;
+
+/**
+ * Restricts index column names to reject sort direction suffixes.
+ */
+export type DSQLIndexColumnName<C extends string> = C extends `${string} ${
+  | "asc"
+  | "desc"
+  | "ASC"
+  | "DESC"}`
+  ? never
+  : C;
+
+/**
+ * Restricts column definition options during table creation in Aurora DSQL.
+ *
+ * This class adds type declarations only. Kysely supplies all runtime behavior.
+ *
+ * @example
+ * ```ts
+ * db.schema.createTable("person").addColumn("id", "uuid", (col) => col.primaryKey());
+ * ```
+ */
+// The contract requires related public type-only builder classes in one module.
+// eslint-disable-next-line max-classes-per-file
+export class DSQLCreateColumnDefinitionBuilder extends ColumnDefinitionBuilder {
+  /**
+   * Makes the column the primary key.
+   *
+   * @returns The restricted column definition builder.
+   */
+  declare primaryKey: () => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Adds a unique constraint for the column.
+   *
+   * @returns The restricted column definition builder.
+   */
+  declare unique: () => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Adds the NULLS NOT DISTINCT specifier.
+   *
+   * @returns The restricted column definition builder.
+   */
+  declare nullsNotDistinct: () => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Adds a NOT NULL constraint for the column.
+   *
+   * @returns The restricted column definition builder.
+   */
+  declare notNull: () => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Adds a default value expression for the column.
+   *
+   * @param args - The default value arguments.
+   * @returns The restricted column definition builder.
+   */
+  declare defaultTo: (
+    ...args: Parameters<ColumnDefinitionBuilder["defaultTo"]>
+  ) => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Adds a check constraint for the column.
+   *
+   * @param args - The check constraint arguments.
+   * @returns The restricted column definition builder.
+   */
+  declare check: (
+    ...args: Parameters<ColumnDefinitionBuilder["check"]>
+  ) => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Makes the column a generated column using GENERATED ALWAYS AS.
+   *
+   * @param args - The generated column arguments.
+   * @returns The restricted column definition builder.
+   */
+  declare generatedAlwaysAs: (
+    ...args: Parameters<ColumnDefinitionBuilder["generatedAlwaysAs"]>
+  ) => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Makes a generated column stored.
+   *
+   * @returns The restricted column definition builder.
+   */
+  declare stored: () => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Adds SQL modifiers directly after the column data type.
+   *
+   * @param args - The modifier arguments.
+   * @returns The restricted column definition builder.
+   */
+  declare modifyFront: (
+    ...args: Parameters<ColumnDefinitionBuilder["modifyFront"]>
+  ) => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Adds SQL modifiers at the end of the column definition.
+   *
+   * @param args - The modifier arguments.
+   * @returns The restricted column definition builder.
+   */
+  declare modifyEnd: (
+    ...args: Parameters<ColumnDefinitionBuilder["modifyEnd"]>
+  ) => DSQLCreateColumnDefinitionBuilder;
+
+  /**
+   * Calls a custom transformation function.
+   *
+   * @param func - The transformation callback.
+   * @returns The callback result.
+   */
+  declare $call: <T>(func: (qb: this) => T) => T;
+
+  declare references: (this: never, ...args: never[]) => never;
+  declare onDelete: (this: never, ...args: never[]) => never;
+  declare onUpdate: (this: never, ...args: never[]) => never;
+  declare autoIncrement: (this: never, ...args: never[]) => never;
+  declare identity: (this: never, ...args: never[]) => never;
+  declare unsigned: (this: never, ...args: never[]) => never;
+  declare generatedAlwaysAsIdentity: (this: never, ...args: never[]) => never;
+  declare generatedByDefaultAsIdentity: (
+    this: never,
+    ...args: never[]
+  ) => never;
+  declare ifNotExists: (this: never, ...args: never[]) => never;
+}
+
+/**
+ * Callback function to configure a column definition during table creation.
+ */
+export type DSQLCreateColumnDefinitionBuilderCallback = (
+  builder: DSQLCreateColumnDefinitionBuilder
+) => DSQLCreateColumnDefinitionBuilder;

package/template/vendor/kysely-dsql/dsql/create-table-builder.ts

@@ -0,0 +1,115 @@
+import { CreateTableBuilder } from "kysely";
+
+import type {
+  DSQLColumnDataType,
+  DSQLCreateColumnDefinitionBuilderCallback,
+} from "./create-column-builder.js";
+
+/**
+ * Restricts table creation builders for Aurora DSQL.
+ *
+ * @template TB - The table name.
+ * @template C - The column names in the builder.
+ * @example
+ * ```ts
+ * db.schema.createTable("person").addColumn("id", "uuid");
+ * ```
+ */
+// eslint-disable-next-line max-classes-per-file
+export class DSQLCreateTableBuilder<
+  TB extends string,
+  C extends string = never,
+> extends CreateTableBuilder<TB, C> {
+  /**
+   * Adds a column with an Aurora DSQL data type.
+   *
+   * @param columnName - The column name.
+   * @param dataType - The Aurora DSQL data type.
+   * @param build - The optional column builder callback.
+   * @returns A restricted builder with the new column name.
+   * @example
+   * ```ts
+   * builder.addColumn("id", "uuid");
+   * ```
+   */
+  declare addColumn: <CN extends string>(
+    columnName: CN,
+    dataType: DSQLColumnDataType,
+    build?: DSQLCreateColumnDefinitionBuilderCallback
+  ) => DSQLCreateTableBuilder<TB, C | CN>;
+
+  /**
+   * Adds a check constraint and keeps the restricted builder.
+   *
+   * @param args - The Kysely check constraint arguments.
+   * @returns The restricted table builder.
+   */
+  declare addCheckConstraint: (
+    ...args: Parameters<CreateTableBuilder<TB, C>["addCheckConstraint"]>
+  ) => DSQLCreateTableBuilder<TB, C>;
+
+  /**
+   * Adds a primary key constraint and keeps the restricted builder.
+   *
+   * @param args - The Kysely primary key constraint arguments.
+   * @returns The restricted table builder.
+   */
+  declare addPrimaryKeyConstraint: (
+    ...args: Parameters<CreateTableBuilder<TB, C>["addPrimaryKeyConstraint"]>
+  ) => DSQLCreateTableBuilder<TB, C>;
+
+  /**
+   * Adds a unique constraint and keeps the restricted builder.
+   *
+   * @param args - The Kysely unique constraint arguments.
+   * @returns The restricted table builder.
+   */
+  declare addUniqueConstraint: (
+    ...args: Parameters<CreateTableBuilder<TB, C>["addUniqueConstraint"]>
+  ) => DSQLCreateTableBuilder<TB, C>;
+
+  /**
+   * Adds the missing-table condition and keeps the restricted builder.
+   *
+   * @returns The restricted table builder.
+   * @example
+   * ```ts
+   * builder.ifNotExists();
+   * ```
+   */
+  declare ifNotExists: () => DSQLCreateTableBuilder<TB, C>;
+
+  /**
+   * Adds SQL at the front and keeps the restricted builder.
+   *
+   * @param args - The modifier arguments.
+   * @returns The restricted table builder.
+   */
+  declare modifyFront: (
+    ...args: Parameters<CreateTableBuilder<TB, C>["modifyFront"]>
+  ) => DSQLCreateTableBuilder<TB, C>;
+
+  /**
+   * Adds SQL at the end and keeps the restricted builder.
+   *
+   * @param args - The modifier arguments.
+   * @returns The restricted table builder.
+   */
+  declare modifyEnd: (
+    ...args: Parameters<CreateTableBuilder<TB, C>["modifyEnd"]>
+  ) => DSQLCreateTableBuilder<TB, C>;
+
+  /**
+   * Calls a custom transformation function.
+   *
+   * @param func - The transformation callback.
+   * @returns The callback result.
+   */
+  declare $call: <T>(func: (qb: this) => T) => T;
+
+  declare temporary: (this: never, ...args: never[]) => never;
+  declare onCommit: (this: never, ...args: never[]) => never;
+  declare as: (this: never, ...args: never[]) => never;
+  declare addIndex: (this: never, ...args: never[]) => never;
+  declare addForeignKeyConstraint: (this: never, ...args: never[]) => never;
+}

package/template/vendor/kysely-dsql/dsql/dialect.ts

@@ -0,0 +1,41 @@
+// oxlint-disable max-classes-per-file typescript/no-explicit-any
+import { PostgresDriver, PostgresIntrospector } from "kysely";
+import type {
+  DatabaseIntrospector,
+  Dialect,
+  DialectAdapter,
+  Driver,
+  Kysely,
+  PostgresDialectConfig,
+  QueryCompiler,
+} from "kysely";
+
+import { DQSLAdapter } from "./adapter.js";
+import { DSQLQueryCompiler } from "./query-compiler.js";
+
+export class DSQLDialect implements Dialect {
+  readonly #config: PostgresDialectConfig;
+
+  constructor(config: PostgresDialectConfig) {
+    this.#config = config;
+  }
+
+  createDriver(): Driver {
+    return new PostgresDriver(this.#config);
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  createQueryCompiler(): QueryCompiler {
+    return new DSQLQueryCompiler();
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  createAdapter(): DialectAdapter {
+    return new DQSLAdapter();
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  createIntrospector(db: Kysely<any>): DatabaseIntrospector {
+    return new PostgresIntrospector(db);
+  }
+}

package/template/vendor/kysely-dsql/dsql/dsql-kysely.ts

@@ -0,0 +1,93 @@
+/**
+ * Supplies a Kysely client with the restricted Aurora DSQL schema module.
+ *
+ * @template DB - The database shape.
+ * @example
+ * ```ts
+ * const client = new DSQLKysely<Database>({ dialect });
+ * ```
+ */
+
+import { Kysely, type KyselyConfig } from "kysely";
+
+import { DSQLSchemaModule } from "./schema-module";
+
+// eslint-disable-next-line max-classes-per-file
+export class DSQLKysely<DB> extends Kysely<DB> {
+  /**
+   * Adds a plugin and keeps the restricted client.
+   *
+   * @param plugin - The Kysely plugin.
+   * @returns A restricted client with the plugin.
+   * @example
+   * ```ts
+   * const client = db.withPlugin(plugin);
+   * ```
+   */
+  // @ts-expect-error DSQLKysely restricts the schema surface for Aurora DSQL.
+  override withPlugin(plugin: KyselyPlugin): DSQLKysely<DB> {
+    // SAFETY: The subclass changes types only and adds no runtime state.
+    return super.withPlugin(plugin) as DSQLKysely<DB>;
+  }
+
+  /**
+   * Removes all plugins and keeps the restricted client.
+   *
+   * @returns A restricted client without plugins.
+   * @example
+   * ```ts
+   * const client = db.withoutPlugins();
+   * ```
+   */
+  // @ts-expect-error DSQLKysely restricts the schema surface for Aurora DSQL.
+  override withoutPlugins(): DSQLKysely<DB> {
+    // SAFETY: The subclass changes types only and adds no runtime state.
+    return super.withoutPlugins() as DSQLKysely<DB>;
+  }
+
+  /**
+   * Selects a schema and keeps the restricted client.
+   *
+   * @param schema - The schema name.
+   * @returns A restricted client for the schema.
+   * @example
+   * ```ts
+   * const client = db.withSchema("public");
+   * ```
+   */
+  // @ts-expect-error DSQLKysely restricts the schema surface for Aurora DSQL.
+  override withSchema(schema: string): DSQLKysely<DB> {
+    // SAFETY: The subclass changes types only and adds no runtime state.
+    return super.withSchema(schema) as DSQLKysely<DB>;
+  }
+
+  /**
+   * Creates a restricted Aurora DSQL client.
+   *
+   * @param config - The Kysely client configuration.
+   * @example
+   * ```ts
+   * const client = new DSQLKysely<Database>({ dialect });
+   * ```
+   */
+  // The explicit constructor documents the public configuration contract.
+  // eslint-disable-next-line no-useless-constructor
+  constructor(config: KyselyConfig) {
+    super(config);
+  }
+
+  /**
+   * Gets the restricted Aurora DSQL schema module.
+   *
+   * @returns The schema module for this client.
+   * @example
+   * ```ts
+   * const schema = db.schema;
+   * ```
+   */
+  // @ts-expect-error DSQLKysely restricts the schema surface for Aurora DSQL.
+  override get schema(): DSQLSchemaModule {
+    // SAFETY: DSQLSchemaModule is an exact subtype extending SchemaModule.
+    return new DSQLSchemaModule(this.getExecutor());
+  }
+}

package/template/vendor/kysely-dsql/dsql/dsql-token.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert";
+
+// oxlint-disable func-style
+import { DsqlSigner } from "@aws-sdk/dsql-signer";
+
+async function getToken(clusterEndpoint: string, region: string) {
+  const signer = new DsqlSigner({
+    hostname: clusterEndpoint,
+    expiresIn: 60_000,
+    region,
+  });
+  return await signer.getDbConnectAdminAuthToken();
+}
+async function main() {
+  const clusterEndpoint = process.env.CLUSTER_ENDPOINT;
+  assert.ok(clusterEndpoint);
+  const user = process.env.CLUSTER_USER;
+  assert.ok(user);
+  const region = process.env.AWS_REGION;
+  assert.ok(region);
+  const token = await getToken(clusterEndpoint, region);
+  console.log({
+    token,
+    encodedToken: encodeURIComponent(token),
+    connectionString: `postgresql://admin:${encodeURIComponent(token)}@${clusterEndpoint}:5432/postgres?sslmode=true`,
+  });
+}
+
+main();