create-monolayer-app 0.1.1 → 0.2.0

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

@@ -0,0 +1,330 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import type { CompiledQuery, QueryResult } from "kysely";
+import { CompiledQuery as KyselyCompiledQuery } from "kysely";
+
+interface TableColumnInfo {
+  readonly columnDefault: string | null;
+  readonly columnName: string;
+  readonly dataType: string;
+  readonly isGenerated: string;
+  readonly isIdentity: string;
+  readonly isNullable: string;
+  readonly tableName: string;
+  readonly udtName: string;
+}
+
+interface ColumnInfo {
+  readonly columnDefault: string | null;
+  readonly columnName: string | null;
+  readonly dataType: string | null;
+  readonly isGenerated: string | null;
+  readonly isIdentity: string | null;
+  readonly isNullable: string | null;
+  readonly tableName: string;
+  readonly udtName: string | null;
+}
+
+interface TypeGenerationConnection {
+  readonly executeQuery: (
+    query: CompiledQuery<ColumnInfo>
+  ) => Promise<QueryResult<ColumnInfo>>;
+}
+
+/** The first line in each generated type file. */
+export const GENERATED_FILE_HEADER =
+  "// This file is generated by @mnlyr-apps/db. Do not edit this file.";
+
+/** The generated database file and table files. */
+export interface GeneratedDatabaseTypes {
+  readonly databaseSource: string;
+  readonly tableSources: ReadonlyMap<string, string>;
+}
+
+const POSTGRES_TYPE_TO_TYPESCRIPT = new Map(
+  Object.entries({
+    bigint: "string",
+    bigserial: "string",
+    bit: "string",
+    boolean: "boolean",
+    bytea: "Uint8Array",
+    character: "string",
+    "character varying": "string",
+    cidr: "string",
+    date: "Date",
+    decimal: "string",
+    "double precision": "number",
+    inet: "string",
+    integer: "number",
+    interval: "unknown",
+    json: "unknown",
+    jsonb: "unknown",
+    macaddr: "string",
+    money: "string",
+    numeric: "string",
+    real: "number",
+    serial: "number",
+    smallint: "number",
+    smallserial: "number",
+    text: "string",
+    time: "string",
+    "time with time zone": "string",
+    "time without time zone": "string",
+    timestamp: "Date",
+    "timestamp with time zone": "Date",
+    "timestamp without time zone": "Date",
+    timestamptz: "Date",
+    tsquery: "string",
+    tsvector: "string",
+    uuid: "string",
+    "USER-DEFINED": "unknown",
+    varchar: "string",
+    xml: "string",
+  })
+);
+
+const POSTGRES_UDT_TO_TYPESCRIPT = new Map(
+  Object.entries({
+    bool: "boolean",
+    bpchar: "string",
+    bytea: "Uint8Array",
+    date: "Date",
+    float4: "number",
+    float8: "number",
+    int2: "number",
+    int4: "number",
+    int8: "string",
+    json: "unknown",
+    jsonb: "unknown",
+    numeric: "string",
+    text: "string",
+    time: "string",
+    timestamp: "Date",
+    timestamptz: "Date",
+    uuid: "string",
+    varchar: "string",
+  })
+);
+
+const INTROSPECTION_SQL = `
+  SELECT
+    t.table_name AS "tableName",
+    c.column_name AS "columnName",
+    c.data_type AS "dataType",
+    c.udt_name AS "udtName",
+    c.is_nullable AS "isNullable",
+    c.column_default AS "columnDefault",
+    c.is_identity AS "isIdentity",
+    c.is_generated AS "isGenerated"
+  FROM information_schema.tables t
+  LEFT JOIN information_schema.columns c
+    ON t.table_schema = c.table_schema
+    AND t.table_name = c.table_name
+  WHERE t.table_schema = $1
+  ORDER BY t.table_name, c.ordinal_position
+`;
+
+const INTERNAL_TABLE_PREFIXES = ["_", "kysely_"] as const;
+
+const capitalize = (value: string): string =>
+  `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+
+const camelCase = (value: string): string =>
+  value.replaceAll(/_[^_]/gu, (match) => match.slice(1).toUpperCase());
+
+const propertyName = (databaseName: string): string => {
+  const name = camelCase(databaseName);
+  return /^[$A-Z_a-z][$\w]*$/u.test(name) ? name : JSON.stringify(name);
+};
+
+const typeName = (databaseName: string): string => {
+  const name = databaseName
+    .split(/[^A-Z_a-z0-9]+/u)
+    .flatMap((part) => part.split("_"))
+    .filter(Boolean)
+    .map(capitalize)
+    .join("");
+
+  return /^\d/u.test(name) ? `Table${name}` : name;
+};
+
+const isTableColumn = (column: ColumnInfo): column is TableColumnInfo =>
+  column.columnName !== null;
+
+const isGeneratedColumn = (column: TableColumnInfo): boolean =>
+  column.columnDefault !== null ||
+  column.isIdentity === "YES" ||
+  column.isGenerated !== "NEVER";
+
+const isInternalTable = (tableName: string): boolean =>
+  INTERNAL_TABLE_PREFIXES.some((prefix) => tableName.startsWith(prefix));
+
+const postgresTypeToTypescript = (column: TableColumnInfo): string => {
+  if (column.dataType === "ARRAY") {
+    const itemType =
+      POSTGRES_UDT_TO_TYPESCRIPT.get(column.udtName.slice(1)) ?? "unknown";
+    return `Array<${itemType}>`;
+  }
+
+  return (
+    POSTGRES_TYPE_TO_TYPESCRIPT.get(column.dataType) ??
+    POSTGRES_UDT_TO_TYPESCRIPT.get(column.udtName) ??
+    "unknown"
+  );
+};
+
+const renderColumn = (column: TableColumnInfo): string => {
+  const nullableType = column.isNullable === "YES" ? ` | null` : "";
+  const dataType = `${postgresTypeToTypescript(column)}${nullableType}`;
+  const kyselyType = isGeneratedColumn(column)
+    ? `Generated<${dataType}>`
+    : dataType;
+
+  return `  ${propertyName(column.columnName)}: ${kyselyType};`;
+};
+
+const renderKyselyImports = (columns: readonly TableColumnInfo[]): string => {
+  const names = ["Insertable", "Selectable", "Updateable"];
+
+  if (columns.some(isGeneratedColumn)) {
+    names.unshift("Generated");
+  }
+
+  return `import type { ${names.toSorted().join(", ")} } from "kysely";`;
+};
+
+const tableFileName = (tableName: string): string => {
+  const fileName = tableName.toLowerCase().replaceAll(/[^a-z0-9]+/gu, "-");
+  return `${fileName.replaceAll(/^-|-$/gu, "")}.ts`;
+};
+
+const renderTableInterface = (
+  name: string,
+  columns: readonly TableColumnInfo[]
+): string => {
+  if (columns.length === 0) {
+    return [
+      "// oxlint-disable-next-line typescript/no-empty-interface typescript/no-empty-object-type",
+      `export interface ${name}Table {}`,
+    ].join("\n");
+  }
+
+  const properties = columns.map(renderColumn).join("\n");
+  return [`export interface ${name}Table {`, properties, "}"].join("\n");
+};
+
+const renderTableTypes = ([tableName, columns]: [
+  string,
+  TableColumnInfo[],
+]): string => {
+  const name = typeName(tableName);
+
+  return [
+    GENERATED_FILE_HEADER,
+    renderKyselyImports(columns),
+    renderTableInterface(name, columns),
+    [
+      `export type ${name} = Selectable<${name}Table>;`,
+      `export type New${name} = Insertable<${name}Table>;`,
+      `export type ${name}Update = Updateable<${name}Table>;`,
+    ].join("\n"),
+  ]
+    .join("\n\n")
+    .concat("\n");
+};
+
+const renderDatabaseImports = (
+  tables: ReadonlyMap<string, readonly TableColumnInfo[]>
+): string[] =>
+  [...tables].map(([tableName]) => {
+    const name = typeName(tableName);
+    const importFile = tableFileName(tableName).replace(/\.ts$/u, ".js");
+    return `import type { ${name}Table } from "./tables/${importFile}";`;
+  });
+
+const renderDatabaseProperties = (
+  tables: ReadonlyMap<string, readonly TableColumnInfo[]>
+): string[] =>
+  [...tables].map(
+    ([tableName]) =>
+      `  ${propertyName(tableName)}: ${typeName(tableName)}Table;`
+  );
+
+const renderDatabaseInterface = (properties: string[]): string => {
+  const databaseInterface =
+    properties.length === 0
+      ? [
+          "// oxlint-disable-next-line typescript/no-empty-interface typescript/no-empty-object-type",
+          "export interface Database {}",
+        ].join("\n")
+      : ["export interface Database {", ...properties, "}"].join("\n");
+  return databaseInterface;
+};
+
+const renderDatabaseType = (
+  tables: ReadonlyMap<string, readonly TableColumnInfo[]>
+): string => {
+  const imports = renderDatabaseImports(tables);
+  const properties = renderDatabaseProperties(tables);
+  const databaseInterface = renderDatabaseInterface(properties);
+  return [GENERATED_FILE_HEADER, imports.join("\n"), databaseInterface]
+    .filter(Boolean)
+    .join("\n\n")
+    .concat("\n");
+};
+
+const groupColumnsByTable = (
+  columns: readonly ColumnInfo[]
+): Map<string, TableColumnInfo[]> => {
+  const tables = new Map<string, TableColumnInfo[]>();
+
+  for (const column of columns) {
+    if (isInternalTable(column.tableName)) {
+      continue;
+    }
+
+    const tableColumns = tables.get(column.tableName) ?? [];
+    if (isTableColumn(column)) {
+      tableColumns.push(column);
+    }
+    tables.set(column.tableName, tableColumns);
+  }
+
+  return tables;
+};
+
+const renderDatabaseTypes = (
+  columns: readonly ColumnInfo[]
+): GeneratedDatabaseTypes => {
+  const tables = groupColumnsByTable(columns);
+  const tableSources = new Map<string, string>();
+
+  for (const table of tables) {
+    const fileName = tableFileName(table[0]);
+    if (tableSources.has(fileName)) {
+      throw new Error(`Two database tables map to ${fileName}.`);
+    }
+    tableSources.set(fileName, renderTableTypes(table));
+  }
+
+  return {
+    databaseSource: renderDatabaseType(tables),
+    tableSources,
+  };
+};
+
+/**
+ * Create Kysely database types from the PostgreSQL public schema.
+ *
+ * @param connection - The Kysely connection for schema queries.
+ * @returns The generated database file and table files.
+ */
+export async function generateTypes(
+  connection: TypeGenerationConnection
+): Promise<GeneratedDatabaseTypes> {
+  const query = KyselyCompiledQuery.raw(INTROSPECTION_SQL, ["public"]);
+  const result = await connection.executeQuery(query);
+
+  return renderDatabaseTypes(result.rows);
+}

package/template/vendor/kysely-dsql/plugins/auto-updated-at.plugin.ts

@@ -0,0 +1,139 @@
+// oxlint-disable max-classes-per-file
+// source: https://github.com/LouisJULIEN/kysely-plugins/blob/main/src/auto-updated-at/auto-updated-at.plugin.ts
+import type {
+  KyselyPlugin,
+  OperationNode,
+  PluginTransformQueryArgs,
+  PluginTransformResultArgs,
+  QueryResult,
+  RootOperationNode,
+  UnknownRow,
+  UpdateQueryNode,
+} from "kysely";
+import {
+  AliasNode,
+  ColumnNode,
+  ColumnUpdateNode,
+  OperationNodeTransformer,
+  RawNode,
+  TableNode,
+} from "kysely";
+
+export class AutoUpdatedAtError extends Error {
+  readonly node?: OperationNode | undefined;
+
+  constructor(
+    message: string,
+    node?: OperationNode | undefined
+    // oxlint-disable-next-line unicorn/custom-error-definition
+  ) {
+    super(message);
+    this.node = node;
+  }
+}
+
+class AutoUpdatedAtQueryTransformer extends OperationNodeTransformer {
+  private updatedAtColumnName: string;
+  private ignoredTables: string[];
+
+  constructor({
+    updatedAtColumnName,
+    ignoredTables,
+  }: {
+    updatedAtColumnName?: string;
+    ignoredTables?: string[];
+  } = {}) {
+    super();
+    this.updatedAtColumnName = updatedAtColumnName || "updated_at";
+    this.ignoredTables = ignoredTables || [];
+  }
+
+  protected override transformUpdateQuery(
+    originalNode: UpdateQueryNode
+  ): UpdateQueryNode {
+    const node = super.transformUpdateQuery(originalNode);
+    return this.setUpdatedAt(node);
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  private resolveUpdateTableName(
+    table: OperationNode | undefined,
+    node: OperationNode
+  ): string {
+    if (table && AliasNode.is(table) && TableNode.is(table.node)) {
+      return table.node.table.identifier.name;
+    }
+    if (table && TableNode.is(table)) {
+      return table.table.identifier.name;
+    }
+    throw new AutoUpdatedAtError("no table to update", node);
+  }
+
+  private hasExplicitUpdatedAt(updates: readonly OperationNode[]): boolean {
+    return updates.some((u) => {
+      if (ColumnUpdateNode.is(u) && ColumnNode.is(u.column)) {
+        const colName = u.column.column.name;
+        return (
+          colName === this.updatedAtColumnName ||
+          colName === "updatedAt" ||
+          colName === "updated_at"
+        );
+      }
+      return false;
+    });
+  }
+
+  private appendUpdatedAt<T extends UpdateQueryNode>(
+    node: T,
+    updates: readonly OperationNode[]
+  ): T {
+    const updateUpdatedAtColumn = ColumnNode.create(this.updatedAtColumnName);
+    const updatedAtUpdate = ColumnUpdateNode.create(
+      updateUpdatedAtColumn,
+      RawNode.createWithSql("NOW()")
+    );
+    return { ...node, updates: [...updates, updatedAtUpdate] };
+  }
+
+  private setUpdatedAt<T extends UpdateQueryNode>(node: T): T {
+    const tableName = this.resolveUpdateTableName(node.table, node);
+    if (!this.tableShouldHaveUpdatedAt(tableName)) {
+      return node;
+    }
+
+    const updates = node.updates || [];
+    if (this.hasExplicitUpdatedAt(updates)) {
+      return node;
+    }
+
+    return this.appendUpdatedAt(node, updates);
+  }
+
+  private tableShouldHaveUpdatedAt(tableName: string): boolean {
+    return (
+      !tableName.startsWith("kysely_") &&
+      !this.ignoredTables.includes(tableName)
+    );
+  }
+}
+
+export class AutoUpdatedAtPlugin implements KyselyPlugin {
+  private transformer: AutoUpdatedAtQueryTransformer;
+
+  constructor(
+    ...args: ConstructorParameters<typeof AutoUpdatedAtQueryTransformer>
+  ) {
+    this.transformer = new AutoUpdatedAtQueryTransformer(...args);
+  }
+
+  transformQuery({ node }: PluginTransformQueryArgs): RootOperationNode {
+    return this.transformer.transformNode(node);
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  transformResult({
+    result,
+  }: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+    return Promise.resolve(result);
+  }
+}

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

@@ -0,0 +1,10 @@
+import { CamelCasePlugin } from "kysely";
+
+import { AutoUpdatedAtPlugin } from "./auto-updated-at.plugin";
+import { SoftDelete } from "./soft-delete.plugin";
+
+export default [
+  new CamelCasePlugin(),
+  new SoftDelete({ ignoredTables: [] }),
+  new AutoUpdatedAtPlugin({ ignoredTables: [] }),
+];

package/template/vendor/kysely-dsql/plugins/soft-delete.plugin.ts

@@ -0,0 +1,217 @@
+// oxlint-disable max-classes-per-file
+// source: https://github.com/LouisJULIEN/kysely-plugins/blob/main/src/soft-delete/soft-delete.plugin.ts
+import type {
+  KyselyPlugin,
+  OperationNode,
+  PluginTransformQueryArgs,
+  PluginTransformResultArgs,
+  QueryResult,
+  RootOperationNode,
+  SelectQueryNode,
+  UnknownRow,
+  UpdateQueryNode,
+} from "kysely";
+import {
+  AliasNode,
+  BinaryOperationNode,
+  ColumnNode,
+  IdentifierNode,
+  JoinNode,
+  OperationNodeTransformer,
+  OperatorNode,
+  RawNode,
+  ReferenceNode,
+  TableNode,
+  WhereNode,
+} from "kysely";
+
+// credits: https://github.com/kysely-org/kysely/issues/803
+
+export class SoftDeleteError extends Error {
+  readonly node?: OperationNode | undefined;
+
+  constructor(
+    message: string,
+    node?: OperationNode | undefined
+    // oxlint-disable-next-line unicorn/custom-error-definition
+  ) {
+    super(message);
+    this.node = node;
+  }
+}
+class SoftDeleteQueryTransformer extends OperationNodeTransformer {
+  private deletedAtColumnName: string;
+  private ignoredTables: string[];
+
+  constructor({
+    deletedAtColumnName,
+    ignoredTables,
+  }: {
+    deletedAtColumnName?: string;
+    ignoredTables?: string[];
+  } = {}) {
+    super();
+    this.deletedAtColumnName = deletedAtColumnName || "deleted_at";
+    this.ignoredTables = ignoredTables || [];
+  }
+
+  protected override transformSelectQuery(
+    originalNode: SelectQueryNode
+  ): SelectQueryNode {
+    const node = super.transformSelectQuery(originalNode);
+    return this.addDeletedAtCondition(node);
+  }
+
+  protected override transformUpdateQuery(
+    originalNode: UpdateQueryNode
+  ): UpdateQueryNode {
+    const node = super.transformUpdateQuery(originalNode);
+    return this.addDeletedAtCondition(node);
+  }
+
+  private appendFromFilters(
+    where: WhereNode | undefined,
+    node: SelectQueryNode | UpdateQueryNode
+  ): WhereNode | undefined {
+    let currentWhere = where;
+    if (node.from) {
+      for (const from of node.from.froms) {
+        const deletedAtReference = this.getDeletedAtReference(from);
+        if (deletedAtReference) {
+          currentWhere = this.addIsNotDeletedFilter(
+            currentWhere,
+            deletedAtReference
+          );
+        }
+      }
+    }
+    return currentWhere;
+  }
+
+  private appendJoinFilters(
+    where: WhereNode | undefined,
+    node: SelectQueryNode | UpdateQueryNode
+  ): WhereNode | undefined {
+    let currentWhere = where;
+    if (node.joins) {
+      for (const join of node.joins) {
+        const deletedAtReference = this.getDeletedAtReference(join);
+        if (deletedAtReference) {
+          currentWhere = this.addIsNotDeletedFilter(
+            currentWhere,
+            deletedAtReference
+          );
+        }
+      }
+    }
+    return currentWhere;
+  }
+
+  private addDeletedAtCondition<T extends SelectQueryNode | UpdateQueryNode>(
+    node: T
+  ): T {
+    let where = this.appendFromFilters(node.where, node);
+    where = this.appendJoinFilters(where, node);
+    return {
+      ...node,
+      where,
+    };
+  }
+
+  private getJoinReference(node: JoinNode): ReferenceNode | null {
+    if (node.table === null) {
+      throw new SoftDeleteError("Join without a table");
+    }
+    return this.getDeletedAtReference(node.table);
+  }
+
+  private getAliasReference(
+    node: AliasNode,
+    deletedAtColumn: ColumnNode
+  ): ReferenceNode | null {
+    if (!IdentifierNode.is(node.alias)) {
+      throw new SoftDeleteError("Alias without identifier", node.alias);
+    }
+
+    const tableAlias = node.alias.name;
+    if (!this.tableShouldHaveDeletedAt(tableAlias)) {
+      return null;
+    }
+    return ReferenceNode.create(deletedAtColumn, TableNode.create(tableAlias));
+  }
+
+  private getTableReference(
+    node: TableNode,
+    deletedAtColumn: ColumnNode
+  ): ReferenceNode | null {
+    const tableName = node.table.identifier.name;
+    if (!this.tableShouldHaveDeletedAt(tableName)) {
+      return null;
+    }
+    return ReferenceNode.create(deletedAtColumn, node);
+  }
+
+  private getDeletedAtReference(node: OperationNode): ReferenceNode | null {
+    if (JoinNode.is(node)) {
+      return this.getJoinReference(node);
+    }
+
+    const deletedAtColumn = ColumnNode.create(this.deletedAtColumnName);
+    if (TableNode.is(node)) {
+      return this.getTableReference(node, deletedAtColumn);
+    }
+    if (AliasNode.is(node)) {
+      return this.getAliasReference(node, deletedAtColumn);
+    }
+
+    throw new SoftDeleteError(
+      `Getting a reference to ${this.deletedAtColumnName} column for ${node.kind} is not supported yet.`,
+      node
+    );
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  private addIsNotDeletedFilter(
+    node: WhereNode | undefined,
+    deletedAtReference: ReferenceNode
+  ): WhereNode {
+    const filterOperation = BinaryOperationNode.create(
+      deletedAtReference,
+      OperatorNode.create("is"),
+      RawNode.createWithSql("null")
+    );
+    if (node === null || node === undefined) {
+      return WhereNode.create(filterOperation);
+    }
+
+    return WhereNode.cloneWithOperation(node, "And", filterOperation);
+  }
+
+  private tableShouldHaveDeletedAt(tableName: string): boolean {
+    return (
+      !tableName.startsWith("kysely_") &&
+      !this.ignoredTables.includes(tableName)
+    );
+  }
+}
+
+export class SoftDelete implements KyselyPlugin {
+  private transformer: SoftDeleteQueryTransformer;
+
+  constructor(
+    ...args: ConstructorParameters<typeof SoftDeleteQueryTransformer>
+  ) {
+    this.transformer = new SoftDeleteQueryTransformer(...args);
+  }
+
+  transformQuery({ node }: PluginTransformQueryArgs): RootOperationNode {
+    return this.transformer.transformNode(node);
+  }
+
+  // oxlint-disable-next-line class-methods-use-this
+  transformResult({
+    result,
+  }: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>> {
+    return Promise.resolve(result);
+  }
+}