metal-orm 1.1.10 → 1.1.16

package/src/core/ast/query.ts

@@ -1,166 +1,166 @@
-import {
-  AliasRefNode,
-  CaseExpressionNode,
-  CastExpressionNode,
-  ColumnNode,
-  ExpressionNode,
-  FunctionNode,
-  OperandNode,
-  ScalarSubqueryNode,
-  WindowFunctionNode
-} from './expression.js';
-import { JoinNode } from './join.js';
-import { OrderDirection } from '../sql/sql.js';
-
-/**
- * AST node representing a table reference in a query
- */
-export interface TableNode {
-  type: 'Table';
-  /** Table name */
-  name: string;
-  /** Optional schema name */
-  schema?: string;
-  /** Optional table alias */
-  alias?: string;
-}
-
-/**
- * AST node representing a function used as a table source (table-valued function)
- */
-export interface FunctionTableNode {
-  type: 'FunctionTable';
-  // Canonical "intent" for dialect-aware table functions (tvf).
-  // If set, compiler resolves via TableFunctionStrategy and can fail fast.
-  key?: string;
-  /** Function name */
-  name: string;
-  /** Optional schema for the function (some dialects) */
-  schema?: string;
-  /** Function arguments as operand nodes */
-  args?: OperandNode[];
-  /** Optional alias for the function table */
-  alias?: string;
-  /** LATERAL flag */
-  lateral?: boolean;
-  /** WITH ORDINALITY flag */
-  withOrdinality?: boolean;
-  /** Optional column aliases */
-  columnAliases?: string[];
-}
-
-/**
- * AST node representing a derived table (subquery with an alias)
- */
-export interface DerivedTableNode {
-  type: 'DerivedTable';
-  /** Subquery providing the rows */
-  query: SelectQueryNode;
-  /** Required alias for the derived table */
-  alias: string;
-  /** Optional column aliases */
-  columnAliases?: string[];
-}
-
-export type TableSourceNode = TableNode | FunctionTableNode | DerivedTableNode;
-
-/**
- * Any expression that can appear in ORDER BY / GROUP BY terms.
- */
-export type OrderingTerm = OperandNode | ExpressionNode | AliasRefNode;
-
-/**
- * AST node representing an ORDER BY clause
- */
-export interface OrderByNode {
-  type: 'OrderBy';
-  /** Expression/operand/alias to order by */
-  term: OrderingTerm;
-  /** Order direction (ASC or DESC) */
-  direction: OrderDirection;
-  /** Optional nulls ordering (NULLS FIRST/LAST) */
-  nulls?: 'FIRST' | 'LAST';
-  /** Optional collation */
-  collation?: string;
-}
-
-/**
- * AST node representing a Common Table Expression (CTE)
- */
-export interface CommonTableExpressionNode {
-  type: 'CommonTableExpression';
-  /** CTE name */
-  name: string;
-  /** Optional column names */
-  columns?: string[];
-  /** CTE query */
-  query: SelectQueryNode;
-  /** Whether the CTE is recursive */
-  recursive: boolean;
-}
-
-/**
- * Supported set operation kinds for compound SELECT queries
- */
-export type SetOperationKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
-
-/**
- * AST node representing a set operation (UNION, INTERSECT, etc.)
- */
-export interface SetOperationNode {
-  type: 'SetOperation';
-  /** Operator to combine queries */
-  operator: SetOperationKind;
-  /** Right-hand query in the compound expression */
-  query: SelectQueryNode;
-}
-
-/**
- * AST node representing a complete SELECT query
- */
-export interface SelectQueryNode {
-  type: 'SelectQuery';
-  /** Optional CTEs (WITH clauses) */
-  ctes?: CommonTableExpressionNode[];
-  /** FROM clause table (either a Table or a FunctionTable) */
-  from: TableSourceNode;
-  /** SELECT clause columns */
-  columns: (
-    ColumnNode |
-    FunctionNode |
-    ScalarSubqueryNode |
-    CaseExpressionNode |
-    CastExpressionNode |
-    WindowFunctionNode
-  )[];
-  /** JOIN clauses */
-  joins: JoinNode[];
-  /** Optional WHERE clause */
-  where?: ExpressionNode;
-  /** Optional GROUP BY clause */
-  groupBy?: OrderingTerm[];
-  /** Optional HAVING clause */
-  having?: ExpressionNode;
-  /** Optional ORDER BY clause */
-  orderBy?: OrderByNode[];
-  /** Optional LIMIT clause */
-  limit?: number;
-  /** Optional OFFSET clause */
-  offset?: number;
-  /** Optional query metadata */
-  meta?: Record<string, unknown>;
-  /** Optional DISTINCT clause */
-  distinct?: ColumnNode[];
-  /** Optional set operations chaining this query with others */
-  setOps?: SetOperationNode[];
-}
-
-export interface InsertValuesSourceNode {
-  type: 'InsertValues';
-  /** Rows of values for INSERT rows */
-  rows: OperandNode[][];
-}
-
+import {
+  AliasRefNode,
+  CaseExpressionNode,
+  CastExpressionNode,
+  ColumnNode,
+  ExpressionNode,
+  FunctionNode,
+  OperandNode,
+  ScalarSubqueryNode,
+  WindowFunctionNode
+} from './expression.js';
+import { JoinNode } from './join.js';
+import { OrderDirection } from '../sql/sql.js';
+
+/**
+ * AST node representing a table reference in a query
+ */
+export interface TableNode {
+  type: 'Table';
+  /** Table name */
+  name: string;
+  /** Optional schema name */
+  schema?: string;
+  /** Optional table alias */
+  alias?: string;
+}
+
+/**
+ * AST node representing a function used as a table source (table-valued function)
+ */
+export interface FunctionTableNode {
+  type: 'FunctionTable';
+  // Canonical "intent" for dialect-aware table functions (tvf).
+  // If set, compiler resolves via TableFunctionStrategy and can fail fast.
+  key?: string;
+  /** Function name */
+  name: string;
+  /** Optional schema for the function (some dialects) */
+  schema?: string;
+  /** Function arguments as operand nodes */
+  args?: OperandNode[];
+  /** Optional alias for the function table */
+  alias?: string;
+  /** LATERAL flag */
+  lateral?: boolean;
+  /** WITH ORDINALITY flag */
+  withOrdinality?: boolean;
+  /** Optional column aliases */
+  columnAliases?: string[];
+}
+
+/**
+ * AST node representing a derived table (subquery with an alias)
+ */
+export interface DerivedTableNode {
+  type: 'DerivedTable';
+  /** Subquery providing the rows */
+  query: SelectQueryNode;
+  /** Required alias for the derived table */
+  alias: string;
+  /** Optional column aliases */
+  columnAliases?: string[];
+}
+
+export type TableSourceNode = TableNode | FunctionTableNode | DerivedTableNode;
+
+/**
+ * Any expression that can appear in ORDER BY / GROUP BY terms.
+ */
+export type OrderingTerm = OperandNode | ExpressionNode | AliasRefNode;
+
+/**
+ * AST node representing an ORDER BY clause
+ */
+export interface OrderByNode {
+  type: 'OrderBy';
+  /** Expression/operand/alias to order by */
+  term: OrderingTerm;
+  /** Order direction (ASC or DESC) */
+  direction: OrderDirection;
+  /** Optional nulls ordering (NULLS FIRST/LAST) */
+  nulls?: 'FIRST' | 'LAST';
+  /** Optional collation */
+  collation?: string;
+}
+
+/**
+ * AST node representing a Common Table Expression (CTE)
+ */
+export interface CommonTableExpressionNode {
+  type: 'CommonTableExpression';
+  /** CTE name */
+  name: string;
+  /** Optional column names */
+  columns?: string[];
+  /** CTE query */
+  query: SelectQueryNode;
+  /** Whether the CTE is recursive */
+  recursive: boolean;
+}
+
+/**
+ * Supported set operation kinds for compound SELECT queries
+ */
+export type SetOperationKind = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
+
+/**
+ * AST node representing a set operation (UNION, INTERSECT, etc.)
+ */
+export interface SetOperationNode {
+  type: 'SetOperation';
+  /** Operator to combine queries */
+  operator: SetOperationKind;
+  /** Right-hand query in the compound expression */
+  query: SelectQueryNode;
+}
+
+/**
+ * AST node representing a complete SELECT query
+ */
+export interface SelectQueryNode {
+  type: 'SelectQuery';
+  /** Optional CTEs (WITH clauses) */
+  ctes?: CommonTableExpressionNode[];
+  /** FROM clause table (either a Table or a FunctionTable) */
+  from: TableSourceNode;
+  /** SELECT clause columns */
+  columns: (
+    ColumnNode |
+    FunctionNode |
+    ScalarSubqueryNode |
+    CaseExpressionNode |
+    CastExpressionNode |
+    WindowFunctionNode
+  )[];
+  /** JOIN clauses */
+  joins: JoinNode[];
+  /** Optional WHERE clause */
+  where?: ExpressionNode;
+  /** Optional GROUP BY clause */
+  groupBy?: OrderingTerm[];
+  /** Optional HAVING clause */
+  having?: ExpressionNode;
+  /** Optional ORDER BY clause */
+  orderBy?: OrderByNode[];
+  /** Optional LIMIT clause */
+  limit?: number;
+  /** Optional OFFSET clause */
+  offset?: number;
+  /** Optional query metadata */
+  meta?: Record<string, unknown>;
+  /** Optional DISTINCT clause */
+  distinct?: ColumnNode[];
+  /** Optional set operations chaining this query with others */
+  setOps?: SetOperationNode[];
+}
+
+export interface InsertValuesSourceNode {
+  type: 'InsertValues';
+  /** Rows of values for INSERT rows */
+  rows: OperandNode[][];
+}
+
 export interface InsertSelectSourceNode {
   type: 'InsertSelect';
   /** SELECT query providing rows */
@@ -208,40 +208,40 @@ export interface InsertQueryNode {
   /** Optional RETURNING clause */
   returning?: ColumnNode[];
 }
-
-export interface UpdateAssignmentNode {
-  /** Column to update */
-  column: ColumnNode;
-  /** Value to set */
-  value: OperandNode;
-}
-
-export interface UpdateQueryNode {
-  type: 'UpdateQuery';
-  /** Table being updated */
-  table: TableNode;
-  /** Optional FROM clause for multi-table updates */
-  from?: TableSourceNode;
-  /** Optional joins applied to the FROM/USING tables */
-  joins?: JoinNode[];
-  /** Assignments for SET clause */
-  set: UpdateAssignmentNode[];
-  /** Optional WHERE clause */
-  where?: ExpressionNode;
-  /** Optional RETURNING clause */
-  returning?: ColumnNode[];
-}
-
-export interface DeleteQueryNode {
-  type: 'DeleteQuery';
-  /** Table to delete from */
-  from: TableNode;
-  /** Optional USING clause for multi-table deletes */
-  using?: TableSourceNode;
-  /** Optional joins applied to the USING clause */
-  joins?: JoinNode[];
-  /** Optional WHERE clause */
-  where?: ExpressionNode;
-  /** Optional RETURNING clause */
-  returning?: ColumnNode[];
-}
+
+export interface UpdateAssignmentNode {
+  /** Column to update */
+  column: ColumnNode;
+  /** Value to set */
+  value: OperandNode;
+}
+
+export interface UpdateQueryNode {
+  type: 'UpdateQuery';
+  /** Table being updated */
+  table: TableNode;
+  /** Optional FROM clause for multi-table updates */
+  from?: TableSourceNode;
+  /** Optional joins applied to the FROM/USING tables */
+  joins?: JoinNode[];
+  /** Assignments for SET clause */
+  set: UpdateAssignmentNode[];
+  /** Optional WHERE clause */
+  where?: ExpressionNode;
+  /** Optional RETURNING clause */
+  returning?: ColumnNode[];
+}
+
+export interface DeleteQueryNode {
+  type: 'DeleteQuery';
+  /** Table to delete from */
+  from: TableNode;
+  /** Optional USING clause for multi-table deletes */
+  using?: TableSourceNode;
+  /** Optional joins applied to the USING clause */
+  joins?: JoinNode[];
+  /** Optional WHERE clause */
+  where?: ExpressionNode;
+  /** Optional RETURNING clause */
+  returning?: ColumnNode[];
+}

package/src/core/ddl/dialects/base-schema-dialect.ts

@@ -93,4 +93,4 @@ export abstract class BaseSchemaDialect implements SchemaDialect {
     return false;
   }
 }
-
+

package/src/core/ddl/dialects/mssql-schema-dialect.ts

@@ -128,4 +128,4 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
     return undefined;
   }
 }
-
+

package/src/core/ddl/dialects/mysql-schema-dialect.ts

@@ -117,4 +117,4 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
     return [`ALTER TABLE ${this.formatTableName(table)} MODIFY COLUMN ${rendered.sql};`];
   }
 }
-
+

package/src/core/ddl/dialects/postgres-schema-dialect.ts

@@ -150,4 +150,4 @@ export class PostgresSchemaDialect extends BaseSchemaDialect {
     return undefined;
   }
 }
-
+

package/src/core/ddl/dialects/render-reference.test.ts

@@ -1,70 +1,70 @@
-import { describe, expect, it } from 'vitest';
-import { BaseSchemaDialect } from './base-schema-dialect.js';
-import { PostgresSchemaDialect } from './postgres-schema-dialect.js';
-import { TableDef } from '../../../schema/table.js';
-import { ForeignKeyReference } from '../../../schema/column-types.js';
-import { createLiteralFormatter } from '../sql-writing.js';
-
-class DummySchemaDialect extends BaseSchemaDialect {
-    readonly name = 'sqlite';
-    private readonly formatter = createLiteralFormatter({
-        booleanTrue: '1',
-        booleanFalse: '0',
-    });
-
-    get literalFormatter() {
-        return this.formatter;
-    }
-
-    quoteIdentifier(id: string): string {
-        return `"${id}"`;
-    }
-
-    renderColumnType(): string {
-        return 'INTEGER';
-    }
-
-    renderAutoIncrement(): string | undefined {
-        return undefined;
-    }
-
-    renderIndex(): string {
-        return 'CREATE INDEX dummy;';
-    }
-}
-
-const table: TableDef = {
-    name: 'child',
-    columns: {},
-    relations: {},
-};
-
-const deferrableReference: ForeignKeyReference = {
-    table: 'parent',
-    column: 'id',
-    deferrable: true,
-    onDelete: 'CASCADE',
-    onUpdate: 'NO ACTION',
-};
-
-describe('renderReference deferrable handling', () => {
-    it('base dialect remains agnostic to deferrable flags', () => {
-        const dialect = new DummySchemaDialect();
-        const sql = dialect.renderReference(deferrableReference, table);
-        expect(sql).toContain('REFERENCES "parent"');
-        expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
-    });
-
-    it('Postgres dialect renders the deferrable clause', () => {
-        const dialect = new PostgresSchemaDialect();
-        const sql = dialect.renderReference(deferrableReference, table);
-        expect(sql).toContain('DEFERRABLE INITIALLY DEFERRED');
-    });
-
-    it('Postgres dialect skips the clause when the flag is missing', () => {
-        const dialect = new PostgresSchemaDialect();
-        const sql = dialect.renderReference({ table: 'parent', column: 'id' }, table);
-        expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
-    });
-});
-
+import { describe, expect, it } from 'vitest';
+import { BaseSchemaDialect } from './base-schema-dialect.js';
+import { PostgresSchemaDialect } from './postgres-schema-dialect.js';
+import { TableDef } from '../../../schema/table.js';
+import { ForeignKeyReference } from '../../../schema/column-types.js';
+import { createLiteralFormatter } from '../sql-writing.js';
+
+class DummySchemaDialect extends BaseSchemaDialect {
+    readonly name = 'sqlite';
+    private readonly formatter = createLiteralFormatter({
+        booleanTrue: '1',
+        booleanFalse: '0',
+    });
+
+    get literalFormatter() {
+        return this.formatter;
+    }
+
+    quoteIdentifier(id: string): string {
+        return `"${id}"`;
+    }
+
+    renderColumnType(): string {
+        return 'INTEGER';
+    }
+
+    renderAutoIncrement(): string | undefined {
+        return undefined;
+    }
+
+    renderIndex(): string {
+        return 'CREATE INDEX dummy;';
+    }
+}
+
+const table: TableDef = {
+    name: 'child',
+    columns: {},
+    relations: {},
+};
+
+const deferrableReference: ForeignKeyReference = {
+    table: 'parent',
+    column: 'id',
+    deferrable: true,
+    onDelete: 'CASCADE',
+    onUpdate: 'NO ACTION',
+};
+
+describe('renderReference deferrable handling', () => {
+    it('base dialect remains agnostic to deferrable flags', () => {
+        const dialect = new DummySchemaDialect();
+        const sql = dialect.renderReference(deferrableReference, table);
+        expect(sql).toContain('REFERENCES "parent"');
+        expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
+    });
+
+    it('Postgres dialect renders the deferrable clause', () => {
+        const dialect = new PostgresSchemaDialect();
+        const sql = dialect.renderReference(deferrableReference, table);
+        expect(sql).toContain('DEFERRABLE INITIALLY DEFERRED');
+    });
+
+    it('Postgres dialect skips the clause when the flag is missing', () => {
+        const dialect = new PostgresSchemaDialect();
+        const sql = dialect.renderReference({ table: 'parent', column: 'id' }, table);
+        expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
+    });
+});
+

package/src/core/ddl/dialects/sqlite-schema-dialect.ts

@@ -119,4 +119,4 @@ export class SQLiteSchemaDialect extends BaseSchemaDialect {
     return `SQLite ALTER COLUMN is not supported; rebuild table ${key} to change column ${column.name}.`;
   }
 }
-
+

package/src/core/ddl/introspect/catalogs/index.ts

@@ -1,5 +1,5 @@
-/** Re-exports for supported catalog definitions. */
-export * from './postgres.js';
-export * from './mssql.js';
-export * from './mysql.js';
-export * from './sqlite.js';
+/** Re-exports for supported catalog definitions. */
+export * from './postgres.js';
+export * from './mssql.js';
+export * from './mysql.js';
+export * from './sqlite.js';