metal-orm 1.0.11 → 1.0.12

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

@@ -1,15 +1,15 @@
-import { CompilerContext, Dialect } from '../abstract.js';
-import { SelectQueryNode, InsertQueryNode, UpdateQueryNode, DeleteQueryNode } from '../../ast/query.js';
-import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
-
-/**
- * SQLite dialect implementation
- */
-export class SqliteDialect extends Dialect {
-  /**
-   * Creates a new SqliteDialect instance
-   */
-  public constructor() {
+import { CompilerContext } from '../abstract.js';
+import { JsonPathNode, ColumnNode } from '../../ast/expression.js';
+import { SqlDialectBase } from '../base/sql-dialect.js';
+
+/**
+ * SQLite dialect implementation
+ */
+export class SqliteDialect extends SqlDialectBase {
+  /**
+   * Creates a new SqliteDialect instance
+   */
+  public constructor() {
     super();
   }
 
@@ -27,120 +27,20 @@ export class SqliteDialect extends Dialect {
    * @param node - JSON path node
    * @returns SQLite JSON path expression
    */
-  protected compileJsonPath(node: JsonPathNode): string {
-    const col = `${this.quoteIdentifier(node.column.table)}.${this.quoteIdentifier(node.column.name)}`;
-    // SQLite uses json_extract(col, '$.path')
-    return `json_extract(${col}, '${node.path}')`;
-  }
-
-  /**
-   * Compiles SELECT query AST to SQLite SQL
-   * @param ast - Query AST
-   * @param ctx - Compiler context
-   * @returns SQLite 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 === 'CaseExpression') {
-        expr = this.compileOperand(c, ctx);
-      } else if (c.type === 'WindowFunction') {
-        expr = this.compileOperand(c, ctx);
-      }
-
-      // Handle alias
-      if (c.alias) {
-        // Backward compat for the raw string parsing alias hack in playground
-        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)}`;
+    // SQLite uses json_extract(col, '$.path')
+    return `json_extract(${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}`;
+  }
+}

package/src/index.ts

@@ -12,6 +12,10 @@ export * from './core/dialect/mysql/index.js';
 export * from './core/dialect/mssql/index.js';
 export * from './core/dialect/sqlite/index.js';
 export * from './core/dialect/postgres/index.js';
+export * from './core/ddl/schema-generator.js';
+export * from './core/ddl/schema-types.js';
+export * from './core/ddl/schema-diff.js';
+export * from './core/ddl/schema-introspect.js';
 export * from './orm/als.js';
 export * from './orm/hydration.js';
 export * from './codegen/typescript.js';

package/src/schema/column.ts

@@ -4,22 +4,68 @@
 export type ColumnType =
   | 'INT'
   | 'INTEGER'
+  | 'BIGINT'
   | 'VARCHAR'
   | 'TEXT'
   | 'JSON'
   | 'ENUM'
+  | 'DECIMAL'
+  | 'FLOAT'
+  | 'DOUBLE'
+  | 'UUID'
+  | 'DATE'
+  | 'DATETIME'
+  | 'TIMESTAMP'
+  | 'TIMESTAMPTZ'
   | 'BOOLEAN'
   | 'int'
   | 'integer'
+  | 'bigint'
   | 'varchar'
   | 'text'
   | 'json'
   | 'enum'
+  | 'decimal'
+  | 'float'
+  | 'double'
+  | 'uuid'
+  | 'date'
+  | 'datetime'
+  | 'timestamp'
+  | 'timestamptz'
   | 'boolean';
-
-/**
- * Definition of a database column
- */
+
+export type ReferentialAction =
+  | 'NO ACTION'
+  | 'RESTRICT'
+  | 'CASCADE'
+  | 'SET NULL'
+  | 'SET DEFAULT';
+
+export interface RawDefaultValue {
+  raw: string;
+}
+
+export type DefaultValue = unknown | RawDefaultValue;
+
+export interface ForeignKeyReference {
+  /** Target table name */
+  table: string;
+  /** Target column name */
+  column: string;
+  /** Optional constraint name */
+  name?: string;
+  /** ON DELETE action */
+  onDelete?: ReferentialAction;
+  /** ON UPDATE action */
+  onUpdate?: ReferentialAction;
+  /** Whether the constraint is deferrable (Postgres) */
+  deferrable?: boolean;
+}
+
+/**
+ * Definition of a database column
+ */
 export interface ColumnDef<T extends ColumnType = ColumnType> {
   /** Column name (filled at runtime by defineTable) */
   name: string;
@@ -29,12 +75,26 @@ export interface ColumnDef<T extends ColumnType = ColumnType> {
   primary?: boolean;
   /** Whether this column cannot be null */
   notNull?: boolean;
+  /** Whether this column must be unique (or name of the unique constraint) */
+  unique?: boolean | string;
+  /** Default value for the column */
+  default?: DefaultValue;
+  /** Whether the column auto-increments / identity */
+  autoIncrement?: boolean;
+  /** Identity strategy where supported */
+  generated?: 'always' | 'byDefault';
+  /** Inline check constraint expression */
+  check?: string;
+  /** Foreign key reference */
+  references?: ForeignKeyReference;
+  /** Column comment/description */
+  comment?: string;
   /** Additional arguments for the column type (e.g., VARCHAR length) */
   args?: any[];
   /** Table name this column belongs to (filled at runtime by defineTable) */
   table?: string;
 }
-
+
 /**
  * Factory for creating column definitions with common data types
  */
@@ -44,30 +104,149 @@ export const col = {
    * @returns ColumnDef with INT type
    */
   int: (): ColumnDef<'INT'> => ({ name: '', type: 'INT' }),
-
-  /**
-   * Creates a variable character column definition
-   * @param length - Maximum length of the string
-   * @returns ColumnDef with VARCHAR type
-   */
+
+  /**
+   * Creates a big integer column definition
+   */
+  bigint: (): ColumnDef<'BIGINT'> => ({ name: '', type: 'BIGINT' }),
+
+  /**
+   * Creates a variable character column definition
+   * @param length - Maximum length of the string
+   * @returns ColumnDef with VARCHAR type
+   */
   varchar: (length: number): ColumnDef<'VARCHAR'> => ({ name: '', type: 'VARCHAR', args: [length] }),
-
-  /**
-   * Creates a JSON column definition
-   * @returns ColumnDef with JSON type
-   */
+
+  /**
+   * Creates a fixed precision decimal column definition
+   */
+  decimal: (precision: number, scale = 0): ColumnDef<'DECIMAL'> => ({
+    name: '',
+    type: 'DECIMAL',
+    args: [precision, scale]
+  }),
+
+  /**
+   * Creates a floating point column definition
+   */
+  float: (precision?: number): ColumnDef<'FLOAT'> => ({
+    name: '',
+    type: 'FLOAT',
+    args: precision !== undefined ? [precision] : undefined
+  }),
+
+  /**
+   * Creates a UUID column definition
+   */
+  uuid: (): ColumnDef<'UUID'> => ({ name: '', type: 'UUID' }),
+
+  /**
+   * Creates a timestamp column definition
+   */
+  timestamp: (): ColumnDef<'TIMESTAMP'> => ({ name: '', type: 'TIMESTAMP' }),
+
+  /**
+   * Creates a timestamptz column definition
+   */
+  timestamptz: (): ColumnDef<'TIMESTAMPTZ'> => ({ name: '', type: 'TIMESTAMPTZ' }),
+
+  /**
+   * Creates a date column definition
+   */
+  date: (): ColumnDef<'DATE'> => ({ name: '', type: 'DATE' }),
+
+  /**
+   * Creates a datetime column definition
+   */
+  datetime: (): ColumnDef<'DATETIME'> => ({ name: '', type: 'DATETIME' }),
+
+  /**
+   * Creates a JSON column definition
+   * @returns ColumnDef with JSON type
+   */
   json: (): ColumnDef<'JSON'> => ({ name: '', type: 'JSON' }),
 
-  /**
-   * Creates a boolean column definition
-   * @returns ColumnDef with BOOLEAN type
-   */
+  /**
+   * Creates a boolean column definition
+   * @returns ColumnDef with BOOLEAN type
+   */
   boolean: (): ColumnDef<'BOOLEAN'> => ({ name: '', type: 'BOOLEAN' }),
-
-  /**
-   * Marks a column definition as a primary key
-   * @param def - Column definition to modify
-   * @returns Modified ColumnDef with primary: true
-   */
-  primaryKey: <T extends ColumnType>(def: ColumnDef<T>): ColumnDef<T> => ({ ...def, primary: true })
+
+  /**
+   * Creates an enum column definition
+   * @param values - Enum values
+   */
+  enum: (values: string[]): ColumnDef<'ENUM'> => ({ name: '', type: 'ENUM', args: values }),
+
+  /**
+   * Marks a column definition as a primary key
+   * @param def - Column definition to modify
+   * @returns Modified ColumnDef with primary: true
+   */
+  primaryKey: <T extends ColumnType>(def: ColumnDef<T>): ColumnDef<T> =>
+    ({ ...def, primary: true }),
+
+  /**
+   * Marks a column as NOT NULL
+   */
+  notNull: <T extends ColumnType>(def: ColumnDef<T>): ColumnDef<T> =>
+    ({ ...def, notNull: true }),
+
+  /**
+   * Marks a column as UNIQUE
+   */
+  unique: <T extends ColumnType>(def: ColumnDef<T>, name?: string): ColumnDef<T> =>
+    ({
+      ...def,
+      unique: name ?? true
+    }),
+
+  /**
+   * Sets a default value for the column
+   */
+  default: <T extends ColumnType>(def: ColumnDef<T>, value: unknown): ColumnDef<T> =>
+    ({
+      ...def,
+      default: value
+    }),
+
+  /**
+   * Sets a raw SQL default value for the column
+   */
+  defaultRaw: <T extends ColumnType>(def: ColumnDef<T>, expression: string): ColumnDef<T> =>
+    ({
+      ...def,
+      default: { raw: expression }
+    }),
+
+  /**
+   * Marks a column as auto-increment / identity
+   */
+  autoIncrement: <T extends ColumnType>(
+    def: ColumnDef<T>,
+    strategy: ColumnDef['generated'] = 'byDefault'
+  ): ColumnDef<T> =>
+    ({
+      ...def,
+      autoIncrement: true,
+      generated: strategy
+    }),
+
+  /**
+   * Adds a foreign key reference
+   */
+  references: <T extends ColumnType>(def: ColumnDef<T>, ref: ForeignKeyReference): ColumnDef<T> =>
+    ({
+      ...def,
+      references: ref
+    }),
+
+  /**
+   * Adds a check constraint to the column
+   */
+  check: <T extends ColumnType>(def: ColumnDef<T>, expression: string): ColumnDef<T> =>
+    ({
+      ...def,
+      check: expression
+    })
 };

package/src/schema/table.ts

@@ -1,11 +1,40 @@
-import { ColumnDef } from './column.js';
-import { RelationDef } from './relation.js';
-
-export interface TableHooks {
-  beforeInsert?(ctx: unknown, entity: any): Promise<void> | void;
-  afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
-  beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
-  afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
+import { ColumnDef } from './column.js';
+import { RelationDef } from './relation.js';
+
+export interface IndexColumn {
+  column: string;
+  order?: 'ASC' | 'DESC';
+  nulls?: 'FIRST' | 'LAST';
+}
+
+export interface IndexDef {
+  name?: string;
+  columns: (string | IndexColumn)[];
+  unique?: boolean;
+  where?: string;
+}
+
+export interface CheckConstraint {
+  name?: string;
+  expression: string;
+}
+
+export interface TableOptions {
+  schema?: string;
+  primaryKey?: string[];
+  indexes?: IndexDef[];
+  checks?: CheckConstraint[];
+  comment?: string;
+  engine?: string;
+  charset?: string;
+  collation?: string;
+}
+
+export interface TableHooks {
+  beforeInsert?(ctx: unknown, entity: any): Promise<void> | void;
+  afterInsert?(ctx: unknown, entity: any): Promise<void> | void;
+  beforeUpdate?(ctx: unknown, entity: any): Promise<void> | void;
+  afterUpdate?(ctx: unknown, entity: any): Promise<void> | void;
   beforeDelete?(ctx: unknown, entity: any): Promise<void> | void;
   afterDelete?(ctx: unknown, entity: any): Promise<void> | void;
 }
@@ -14,16 +43,30 @@ export interface TableHooks {
  * Definition of a database table with its columns and relationships
  * @typeParam T - Type of the columns record
  */
-export interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
-  /** Name of the table */
-  name: string;
-  /** Record of column definitions keyed by column name */
-  columns: T;
-  /** Record of relationship definitions keyed by relation name */
-  relations: Record<string, RelationDef>;
-  /** Optional lifecycle hooks */
-  hooks?: TableHooks;
-}
+export interface TableDef<T extends Record<string, ColumnDef> = Record<string, ColumnDef>> {
+  /** Name of the table */
+  name: string;
+  /** Optional schema/catalog name */
+  schema?: string;
+  /** Record of column definitions keyed by column name */
+  columns: T;
+  /** Record of relationship definitions keyed by relation name */
+  relations: Record<string, RelationDef>;
+  /** Optional lifecycle hooks */
+  hooks?: TableHooks;
+  /** Composite primary key definition (falls back to column.primary flags) */
+  primaryKey?: string[];
+  /** Secondary indexes */
+  indexes?: IndexDef[];
+  /** Table-level check constraints */
+  checks?: CheckConstraint[];
+  /** Table comment/description */
+  comment?: string;
+  /** Dialect-specific options */
+  engine?: string;
+  charset?: string;
+  collation?: string;
+}
 
 /**
  * Creates a table definition with columns and relationships
@@ -42,17 +85,31 @@ export interface TableDef<T extends Record<string, ColumnDef> = Record<string, C
  * });
  * ```
  */
-export const defineTable = <T extends Record<string, ColumnDef>>(
-    name: string,
-    columns: T,
-    relations: Record<string, RelationDef> = {},
-    hooks?: TableHooks
-): TableDef<T> => {
-  // Runtime mutability to assign names to column definitions for convenience
-  const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
-    (acc as any)[key] = { ...def, name: key, table: name };
-    return acc;
-  }, {} as T);
-
-  return { name, columns: colsWithNames, relations, hooks };
-};
+export const defineTable = <T extends Record<string, ColumnDef>>(
+    name: string,
+    columns: T,
+    relations: Record<string, RelationDef> = {},
+    hooks?: TableHooks,
+    options: TableOptions = {}
+): TableDef<T> => {
+  // Runtime mutability to assign names to column definitions for convenience
+  const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
+    (acc as any)[key] = { ...def, name: key, table: name };
+    return acc;
+  }, {} as T);
+
+  return {
+    name,
+    schema: options.schema,
+    columns: colsWithNames,
+    relations,
+    hooks,
+    primaryKey: options.primaryKey,
+    indexes: options.indexes,
+    checks: options.checks,
+    comment: options.comment,
+    engine: options.engine,
+    charset: options.charset,
+    collation: options.collation
+  };
+};

package/src/schema/types.ts

@@ -10,11 +10,14 @@ import {
 /**
  * Maps a ColumnDef to its TypeScript type representation
  */
-export type ColumnToTs<T extends ColumnDef> =
-  T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number :
-  T['type'] extends 'BOOLEAN' | 'boolean' ? boolean :
-  T['type'] extends 'JSON' | 'json' ? unknown :
-  string;
+export type ColumnToTs<T extends ColumnDef> =
+  T['type'] extends 'INT' | 'INTEGER' | 'int' | 'integer' ? number :
+  T['type'] extends 'BIGINT' | 'bigint' ? number | bigint :
+  T['type'] extends 'DECIMAL' | 'decimal' | 'FLOAT' | 'float' | 'DOUBLE' | 'double' ? number :
+  T['type'] extends 'BOOLEAN' | 'boolean' ? boolean :
+  T['type'] extends 'JSON' | 'json' ? unknown :
+  T['type'] extends 'DATE' | 'date' | 'DATETIME' | 'datetime' | 'TIMESTAMP' | 'timestamp' | 'TIMESTAMPTZ' | 'timestamptz' ? string :
+  string;
 
 /**
  * Infers a row shape from a table definition