metal-orm 1.0.10 → 1.0.12

package/src/core/ddl/schema-introspect.ts

@@ -0,0 +1,32 @@
+import { DialectName } from './schema-generator.js';
+import { DatabaseSchema } from './schema-types.js';
+import { DbExecutor } from '../../orm/db-executor.js';
+import type { IntrospectOptions, SchemaIntrospector } from './introspect/types.js';
+import { postgresIntrospector } from './introspect/postgres.js';
+import { mysqlIntrospector } from './introspect/mysql.js';
+import { sqliteIntrospector } from './introspect/sqlite.js';
+import { mssqlIntrospector } from './introspect/mssql.js';
+
+const INTROSPECTORS: Record<DialectName, SchemaIntrospector> = {
+  postgres: postgresIntrospector,
+  mysql: mysqlIntrospector,
+  sqlite: sqliteIntrospector,
+  mssql: mssqlIntrospector
+};
+
+/**
+ * Introspects an existing database schema using the dialect-specific strategy.
+ */
+export const introspectSchema = async (
+  executor: DbExecutor,
+  dialect: DialectName,
+  options: IntrospectOptions = {}
+): Promise<DatabaseSchema> => {
+  const handler = INTROSPECTORS[dialect];
+  if (!handler) {
+    throw new Error(`Unsupported dialect for introspection: ${dialect}`);
+  }
+  return handler.introspect(executor, options);
+};
+
+export type { IntrospectOptions, SchemaIntrospector };

package/src/core/ddl/schema-types.ts

@@ -0,0 +1,39 @@
+import { ForeignKeyReference } from '../../schema/column.js';
+import { IndexColumn } from '../../schema/table.js';
+
+export interface DatabaseColumn {
+  name: string;
+  type: string;
+  notNull?: boolean;
+  default?: unknown;
+  autoIncrement?: boolean;
+  generated?: 'always' | 'byDefault';
+  unique?: boolean | string;
+  references?: ForeignKeyReference;
+  check?: string;
+}
+
+export interface DatabaseIndex {
+  name: string;
+  columns: IndexColumn[];
+  unique?: boolean;
+  where?: string;
+}
+
+export interface DatabaseCheck {
+  name?: string;
+  expression: string;
+}
+
+export interface DatabaseTable {
+  name: string;
+  schema?: string;
+  columns: DatabaseColumn[];
+  primaryKey?: string[];
+  indexes?: DatabaseIndex[];
+  checks?: DatabaseCheck[];
+}
+
+export interface DatabaseSchema {
+  tables: DatabaseTable[];
+}

package/src/core/dialect/base/sql-dialect.ts

@@ -0,0 +1,161 @@
+import { CompilerContext, Dialect } from '../abstract.js';
+import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
+import { ColumnNode } from '../../ast/expression.js';
+
+/**
+ * Shared SQL compiler for dialects with standard LIMIT/OFFSET pagination.
+ * Concrete dialects override only the minimal hooks (identifier quoting,
+ * JSON path, placeholders, RETURNING support) instead of re-implementing
+ * the entire compile pipeline.
+ */
+export abstract class SqlDialectBase extends Dialect {
+  /**
+   * Quotes an identifier (dialect-specific).
+   */
+  abstract quoteIdentifier(id: string): string;
+
+  /**
+   * Compiles SELECT query AST to SQL using common rules.
+   */
+  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
+    const ctes = this.compileCtes(ast, ctx);
+    const columns = this.compileSelectColumns(ast, ctx);
+    const from = this.compileFrom(ast.from);
+    const joins = this.compileJoins(ast, ctx);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const groupBy = this.compileGroupBy(ast);
+    const having = this.compileHaving(ast, ctx);
+    const orderBy = this.compileOrderBy(ast);
+    const pagination = this.compilePagination(ast, orderBy);
+
+    return `${ctes}SELECT ${this.compileDistinct(ast)}${columns} FROM ${from}${joins}${whereClause}${groupBy}${having}${orderBy}${pagination}`;
+  }
+
+  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
+    const table = this.compileTableName(ast.into);
+    const columnList = ast.columns
+      .map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`)
+      .join(', ');
+    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning}`;
+  }
+
+  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
+    const table = this.compileTableName(ast.table);
+    const assignments = ast.set.map(assignment => {
+      const col = assignment.column;
+      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
+      const value = this.compileOperand(assignment.value, ctx);
+      return `${target} = ${value}`;
+    }).join(', ');
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `UPDATE ${table} SET ${assignments}${whereClause}${returning}`;
+  }
+
+  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
+    const table = this.compileTableName(ast.from);
+    const whereClause = this.compileWhere(ast.where, ctx);
+    const returning = this.compileReturning(ast.returning, ctx);
+    return `DELETE FROM ${table}${whereClause}${returning}`;
+  }
+
+  /**
+   * Default RETURNING compilation: no support.
+   */
+  protected compileReturning(returning: ColumnNode[] | undefined, _ctx: CompilerContext): string {
+    if (!returning || returning.length === 0) return '';
+    throw new Error('RETURNING is not supported by this dialect.');
+  }
+
+  /**
+   * DISTINCT clause. Override for DISTINCT ON support.
+   */
+  protected compileDistinct(ast: SelectQueryNode): string {
+    return ast.distinct ? 'DISTINCT ' : '';
+  }
+
+  protected compileSelectColumns(ast: SelectQueryNode, ctx: CompilerContext): string {
+    return ast.columns.map(c => {
+      const expr = this.compileOperand(c, ctx);
+      if (c.alias) {
+        if (c.alias.includes('(')) return c.alias;
+        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
+      }
+      return expr;
+    }).join(', ');
+  }
+
+  protected compileFrom(ast: SelectQueryNode['from']): string {
+    const base = this.compileTableName(ast);
+    return ast.alias ? `${base} AS ${this.quoteIdentifier(ast.alias)}` : base;
+  }
+
+  protected compileTableName(table: { name: string; schema?: string }): string {
+    if (table.schema) {
+      return `${this.quoteIdentifier(table.schema)}.${this.quoteIdentifier(table.name)}`;
+    }
+    return this.quoteIdentifier(table.name);
+  }
+
+  protected compileJoins(ast: SelectQueryNode, ctx: CompilerContext): string {
+    if (!ast.joins || ast.joins.length === 0) return '';
+    const parts = ast.joins.map(j => {
+      const table = this.compileFrom(j.table);
+      const cond = this.compileExpression(j.condition, ctx);
+      return `${j.kind} JOIN ${table} ON ${cond}`;
+    });
+    return ` ${parts.join(' ')}`;
+  }
+
+  protected compileGroupBy(ast: SelectQueryNode): string {
+    if (!ast.groupBy || ast.groupBy.length === 0) return '';
+    const cols = ast.groupBy
+      .map(c => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`)
+      .join(', ');
+    return ` GROUP BY ${cols}`;
+  }
+
+  protected compileHaving(ast: SelectQueryNode, ctx: CompilerContext): string {
+    if (!ast.having) return '';
+    return ` HAVING ${this.compileExpression(ast.having, ctx)}`;
+  }
+
+  protected compileOrderBy(ast: SelectQueryNode): string {
+    if (!ast.orderBy || ast.orderBy.length === 0) return '';
+    const parts = ast.orderBy
+      .map(o => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`)
+      .join(', ');
+    return ` ORDER BY ${parts}`;
+  }
+
+  /**
+   * Default LIMIT/OFFSET pagination clause.
+   */
+  protected compilePagination(ast: SelectQueryNode, _orderByClause: string): string {
+    const parts: string[] = [];
+    if (ast.limit !== undefined) parts.push(`LIMIT ${ast.limit}`);
+    if (ast.offset !== undefined) parts.push(`OFFSET ${ast.offset}`);
+    return parts.length ? ` ${parts.join(' ')}` : '';
+  }
+
+  protected compileCtes(ast: SelectQueryNode, ctx: CompilerContext): string {
+    if (!ast.ctes || ast.ctes.length === 0) return '';
+    const hasRecursive = ast.ctes.some(cte => cte.recursive);
+    const prefix = hasRecursive ? 'WITH RECURSIVE ' : 'WITH ';
+    const cteDefs = ast.ctes.map(cte => {
+      const name = this.quoteIdentifier(cte.name);
+      const cols = cte.columns && cte.columns.length
+        ? `(${cte.columns.map(c => this.quoteIdentifier(c)).join(', ')})`
+        : '';
+      const query = this.stripTrailingSemicolon(this.compileSelectAst(cte.query, ctx));
+      return `${name}${cols} AS (${query})`;
+    }).join(', ');
+    return `${prefix}${cteDefs} `;
+  }
+
+  protected stripTrailingSemicolon(sql: string): string {
+    return sql.trim().replace(/;$/, '');
+  }
+}

package/src/core/dialect/mysql/index.ts

@@ -1,16 +1,15 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
-import { JsonPathNode } from '../../ast/expression.js';
-
-/**
- * MySQL dialect implementation
- */
-export class MySqlDialect extends Dialect {
-  /**
-   * Creates a new MySqlDialect instance
-   */
-  public constructor() {
-    super();
+import { JsonPathNode } from '../../ast/expression.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+
+/**
+ * MySQL dialect implementation
+ */
+export class MySqlDialect extends SqlDialectBase {
+  /**
+   * Creates a new MySqlDialect instance
+   */
+  public constructor() {
+    super();
   }
 
   /**
@@ -27,102 +26,9 @@ export class MySqlDialect extends Dialect {
    * @param node - JSON path node
    * @returns MySQL JSON path expression
    */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // MySQL 5.7+ uses col->'$.path'
-    return `${col}->'${node.path}'`;
-  }
-
-  /**
-   * Compiles SELECT query AST to MySQL SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns MySQL SQL string
-   */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const columns = ast.columns.map(c => {
-      let expr = '';
-      if (c.type === 'Function') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'Column') {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === 'ScalarSubquery') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'WindowFunction') {
-        expr = this.compileOperand(c, ctx);
-      }
-
-      if (c.alias) {
-        if (c.alias.includes('(')) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(', ');
-
-    const distinct = ast.distinct ? 'DISTINCT ' : '';
-    const from = `${this.quoteIdentifier(ast.from.name)}`;
-
-    const joins = ast.joins.map(j => {
-      const table = this.quoteIdentifier(j.table.name);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(' ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-
-    const groupBy = ast.groupBy && ast.groupBy.length > 0
-      ? ' GROUP BY ' + ast.groupBy.map(c => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(', ')
-      : '';
-
-    const having = ast.having
-      ? ` HAVING ${this.compileExpression(ast.having, ctx)}`
-      : '';
-
-    const orderBy = ast.orderBy && ast.orderBy.length > 0
-      ? ' ORDER BY ' + ast.orderBy.map(o => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(', ')
-      : '';
-
-    const limit = ast.limit ? ` LIMIT ${ast.limit}` : '';
-    const offset = ast.offset ? ` OFFSET ${ast.offset}` : '';
-
-    const ctes = ast.ctes && ast.ctes.length > 0
-      ? (() => {
-        const hasRecursive = ast.ctes.some(cte => cte.recursive);
-        const prefix = hasRecursive ? 'WITH RECURSIVE ' : 'WITH ';
-        const cteDefs = ast.ctes.map(cte => {
-          const name = this.quoteIdentifier(cte.name);
-          const cols = cte.columns ? `(${cte.columns.map(c => this.quoteIdentifier(c)).join(', ')})` : '';
-          const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, '');
-          return `${name}${cols} AS (${query})`;
-        }).join(', ');
-        return prefix + cteDefs + ' ';
-      })()
-      : '';
-
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
-    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values};`;
-  }
-
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map(assignment => {
-      const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(', ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause};`;
-  }
-
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    return `DELETE FROM ${table}${whereClause};`;
-  }
-}
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // MySQL 5.7+ uses col->'$.path'
+    return `${col}->'${node.path}'`;
+  }
+}

package/src/core/dialect/postgres/index.ts

@@ -1,16 +1,16 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
-import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
-
-/**
- * PostgreSQL dialect implementation
- */
-export class PostgresDialect extends Dialect {
-  /**
-   * Creates a new PostgresDialect instance
-   */
-  public constructor() {
-    super();
+import { CompilerContext } from '../abstract.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+
+/**
+ * PostgreSQL dialect implementation
+ */
+export class PostgresDialect extends SqlDialectBase {
+  /**
+   * Creates a new PostgresDialect instance
+   */
+  public constructor() {
+    super();
   }
 
   /**
@@ -27,116 +27,20 @@ export class PostgresDialect extends Dialect {
    * @param node - JSON path node
    * @returns PostgreSQL JSON path expression
    */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // Postgres uses col->>'path' for text extraction
-    return `${col}->>'${node.path}'`;
-  }
-
-  /**
-   * Compiles SELECT query AST to PostgreSQL SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns PostgreSQL SQL string
-   */
-  protected compileSelectAst(ast: SelectQueryNode, ctx: CompilerContext): string {
-    const columns = ast.columns.map(c => {
-      let expr = '';
-      if (c.type === 'Function') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'Column') {
-        expr = `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`;
-      } else if (c.type === 'ScalarSubquery') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'WindowFunction') {
-        expr = this.compileOperand(c, ctx);
-      }
-
-      if (c.alias) {
-        if (c.alias.includes('(')) return c.alias;
-        return `${expr} AS ${this.quoteIdentifier(c.alias)}`;
-      }
-      return expr;
-    }).join(', ');
-
-    const distinct = ast.distinct ? 'DISTINCT ' : '';
-    const from = `${this.quoteIdentifier(ast.from.name)}`;
-
-    const joins = ast.joins.map(j => {
-      const table = this.quoteIdentifier(j.table.name);
-      const cond = this.compileExpression(j.condition, ctx);
-      return `${j.kind} JOIN ${table} ON ${cond}`;
-    }).join(' ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-
-    const groupBy = ast.groupBy && ast.groupBy.length > 0
-      ? ' GROUP BY ' + ast.groupBy.map(c => `${this.quoteIdentifier(c.table)}.${this.quoteIdentifier(c.name)}`).join(', ')
-      : '';
-
-    const having = ast.having
-      ? ` HAVING ${this.compileExpression(ast.having, ctx)}`
-      : '';
-
-    const orderBy = ast.orderBy && ast.orderBy.length > 0
-      ? ' ORDER BY ' + ast.orderBy.map(o => `${this.quoteIdentifier(o.column.table)}.${this.quoteIdentifier(o.column.name)} ${o.direction}`).join(', ')
-      : '';
-
-    const limit = ast.limit ? ` LIMIT ${ast.limit}` : '';
-    const offset = ast.offset ? ` OFFSET ${ast.offset}` : '';
-
-    const ctes = ast.ctes && ast.ctes.length > 0
-      ? (() => {
-        const hasRecursive = ast.ctes.some(cte => cte.recursive);
-        const prefix = hasRecursive ? 'WITH RECURSIVE ' : 'WITH ';
-        const cteDefs = ast.ctes.map(cte => {
-          const name = this.quoteIdentifier(cte.name);
-          const cols = cte.columns ? `(${cte.columns.map(c => this.quoteIdentifier(c)).join(', ')})` : '';
-          const query = this.compileSelectAst(cte.query, ctx).trim().replace(/;$/, '');
-          return `${name}${cols} AS (${query})`;
-        }).join(', ');
-        return prefix + cteDefs + ' ';
-      })()
-      : '';
-
-    return `${ctes}SELECT ${distinct}${columns} FROM ${from}${joins ? ' ' + joins : ''}${whereClause}${groupBy}${having}${orderBy}${limit}${offset};`;
-  }
-
-  protected compileInsertAst(ast: InsertQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.into.name);
-    const columnList = ast.columns.map(column => `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`).join(', ');
-    const values = ast.values.map(row => `(${row.map(value => this.compileOperand(value, ctx)).join(', ')})`).join(', ');
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `INSERT INTO ${table} (${columnList}) VALUES ${values}${returning};`;
-  }
-
-  protected compileUpdateAst(ast: UpdateQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.table.name);
-    const assignments = ast.set.map(assignment => {
-      const col = assignment.column;
-      const target = `${this.quoteIdentifier(col.table)}.${this.quoteIdentifier(col.name)}`;
-      const value = this.compileOperand(assignment.value, ctx);
-      return `${target} = ${value}`;
-    }).join(', ');
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `UPDATE ${table} SET ${assignments}${whereClause}${returning};`;
-  }
-
-  protected compileDeleteAst(ast: DeleteQueryNode, ctx: CompilerContext): string {
-    const table = this.quoteIdentifier(ast.from.name);
-    const whereClause = this.compileWhere(ast.where, ctx);
-    const returning = this.compileReturning(ast.returning, ctx);
-    return `DELETE FROM ${table}${whereClause}${returning};`;
-  }
-
-  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
-    if (!returning || returning.length === 0) return '';
-    const columns = returning
-      .map(column => {
-        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
-        return `${tablePart}${this.quoteIdentifier(column.name)}`;
-      })
-      .join(', ');
-    return ` RETURNING ${columns}`;
-  }
-}
+  protected compileJsonPath(node: JsonPathNode): string {
+    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
+    // Postgres uses col->>'path' for text extraction
+    return `${col}->>'${node.path}'`;
+  }
+
+  protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    if (!returning || returning.length === 0) return '';
+    const columns = returning
+      .map(column => {
+        const tablePart = column.table ? `${this.quoteIdentifier(column.table)}.` : '';
+        return `${tablePart}${this.quoteIdentifier(column.name)}`;
+      })
+      .join(', ');
+    return ` RETURNING ${columns}`;
+  }
+}