metal-orm 1.0.45 → 1.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/scripts/generate-entities.mjs

@@ -267,6 +267,7 @@ const renderColumnExpression = (column, tablePk) => {
 };
 
 const mapRelations = tables => {
+  const normalizeName = name => (typeof name === 'string' && name.includes('.') ? name.split('.').pop() : name);
   const relationMap = new Map();
   const relationKeys = new Map();
   const fkIndex = new Map();
@@ -283,12 +284,15 @@ const mapRelations = tables => {
     }
   }
 
-  const findTable = name => tables.find(t => t.name === name);
+  const findTable = name => {
+    const norm = normalizeName(name);
+    return tables.find(t => t.name === name || t.name === norm);
+  };
 
   const pivotTables = new Set();
   for (const table of tables) {
     const fkCols = fkIndex.get(table.name) || [];
-    const distinctTargets = Array.from(new Set(fkCols.map(c => c.references.table)));
+    const distinctTargets = Array.from(new Set(fkCols.map(c => normalizeName(c.references.table))));
     if (fkCols.length === 2 && distinctTargets.length === 2) {
       const [a, b] = fkCols;
       pivotTables.add(table.name);
@@ -329,8 +333,11 @@ const mapRelations = tables => {
     const fkCols = fkIndex.get(table.name) || [];
     for (const fk of fkCols) {
       const targetTable = fk.references.table;
+      const targetKey = normalizeName(targetTable);
       const belongsKey = relationKeys.get(table.name);
-      const hasManyKey = relationKeys.get(targetTable);
+      const hasManyKey = targetKey ? relationKeys.get(targetKey) : undefined;
+
+      if (!belongsKey || !hasManyKey) continue;
 
       const belongsProp = deriveBelongsToName(fk.name, targetTable);
       if (!belongsKey.has(belongsProp)) {
@@ -346,7 +353,7 @@ const mapRelations = tables => {
       const hasManyProp = deriveHasManyName(table.name);
       if (!hasManyKey.has(hasManyProp)) {
         hasManyKey.add(hasManyProp);
-        relationMap.get(targetTable)?.push({
+        relationMap.get(targetKey)?.push({
           kind: 'hasMany',
           property: hasManyProp,
           target: table.name,
@@ -362,12 +369,32 @@ const mapRelations = tables => {
 const renderEntityFile = (schema, options) => {
   const tables = schema.tables.map(t => ({
     name: t.name,
+    schema: t.schema,
     columns: t.columns,
     primaryKey: t.primaryKey || []
   }));
 
   const classNames = new Map();
-  tables.forEach(t => classNames.set(t.name, deriveClassName(t.name)));
+  tables.forEach(t => {
+    const className = deriveClassName(t.name);
+    classNames.set(t.name, className);
+    if (t.schema) {
+      const qualified = `${t.schema}.${t.name}`;
+      if (!classNames.has(qualified)) {
+        classNames.set(qualified, className);
+      }
+    }
+  });
+
+  const resolveClassName = target => {
+    if (!target) return undefined;
+    if (classNames.has(target)) return classNames.get(target);
+    const fallback = target.split('.').pop();
+    if (fallback && classNames.has(fallback)) {
+      return classNames.get(fallback);
+    }
+    return undefined;
+  };
 
   const relations = mapRelations(tables);
 
@@ -469,7 +496,7 @@ const renderEntityFile = (schema, options) => {
 
     const rels = relations.get(table.name) || [];
     for (const rel of rels) {
-      const targetClass = classNames.get(rel.target);
+      const targetClass = resolveClassName(rel.target);
       if (!targetClass) continue;
       switch (rel.kind) {
         case 'belongsTo':
@@ -487,10 +514,10 @@ const renderEntityFile = (schema, options) => {
           lines.push('');
           break;
         case 'belongsToMany':
+          const pivotClass = resolveClassName(rel.pivotTable);
+          if (!pivotClass) break;
           lines.push(
-            `  @BelongsToMany({ target: () => ${targetClass}, pivotTable: () => ${classNames.get(
-              rel.pivotTable
-            )}, pivotForeignKeyToRoot: '${escapeJsString(rel.pivotForeignKeyToRoot)}', pivotForeignKeyToTarget: '${escapeJsString(rel.pivotForeignKeyToTarget)}' })`
+            `  @BelongsToMany({ target: () => ${targetClass}, pivotTable: () => ${pivotClass}, pivotForeignKeyToRoot: '${escapeJsString(rel.pivotForeignKeyToRoot)}', pivotForeignKeyToTarget: '${escapeJsString(rel.pivotForeignKeyToTarget)}' })`
           );
           lines.push(`  ${rel.property}!: ManyToManyCollection<${targetClass}>;`);
           lines.push('');

package/src/codegen/typescript.ts

@@ -17,6 +17,7 @@ import {
   LiteralNode,
   FunctionNode,
   AliasRefNode,
+  CastExpressionNode,
   ExpressionVisitor,
   OperandVisitor,
   visitExpression,
@@ -41,7 +42,8 @@ type SelectionColumn =
   | FunctionNode
   | ScalarSubqueryNode
   | CaseExpressionNode
-  | WindowFunctionNode;
+  | WindowFunctionNode
+  | CastExpressionNode;
 
 export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
   constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) { }
@@ -181,15 +183,16 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
         return `${this.namingStrategy.tableToSymbol(term.table)}.${term.name}`;
       case 'AliasRef':
         return this.visitAliasRef(term);
-      case 'Literal':
-      case 'Function':
-      case 'JsonPath':
-      case 'ScalarSubquery':
-      case 'CaseExpression':
-      case 'WindowFunction':
-        return this.printOperand(term);
-      default:
-        return this.printExpression(term);
+    case 'Literal':
+    case 'Function':
+    case 'JsonPath':
+    case 'ScalarSubquery':
+    case 'CaseExpression':
+    case 'WindowFunction':
+    case 'Cast':
+      return this.printOperand(term);
+    default:
+      return this.printExpression(term);
     }
   }
 
@@ -263,6 +266,10 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return this.printWindowFunctionOperand(node);
   }
 
+  public visitCast(node: CastExpressionNode): string {
+    return this.printCastOperand(node);
+  }
+
   public visitAliasRef(node: AliasRefNode): string {
     return `aliasRef('${node.name}')`;
   }
@@ -454,6 +461,11 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return result;
   }
 
+  private printCastOperand(node: CastExpressionNode): string {
+    const typeLiteral = node.castType.replace(/'/g, "\\'");
+    return `cast(${this.printOperand(node.expression)}, '${typeLiteral}')`;
+  }
+
   /**
    * Converts method chain lines to inline format
    * @param lines - Method chain lines

package/src/core/ast/adapters.ts

@@ -1,4 +1,4 @@
-import { ColumnDef } from '../../schema/column.js';
+import { ColumnDef } from '../../schema/column-types.js';
 import { TableDef } from '../../schema/table.js';
 import { ColumnRef, TableRef } from './types.js';
 
@@ -25,3 +25,4 @@ export const toTableRef = (table: TableRef | TableDef): TableRef => ({
   schema: table.schema,
   alias: hasAlias(table) ? table.alias : undefined
 });
+

package/src/core/ast/expression-builders.ts

@@ -7,6 +7,7 @@ import {
   JsonPathNode,
   OperandNode,
   CaseExpressionNode,
+  CastExpressionNode,
   BinaryExpressionNode,
   ExpressionNode,
   LogicalExpressionNode,
@@ -407,6 +408,18 @@ export const caseWhen = (
   else: elseValue !== undefined ? toOperand(elseValue) : undefined
 });
 
+/**
+ * Builds a CAST expression node for casting values to SQL types.
+ */
+export const cast = (
+  expression: OperandNode | ColumnRef | string | number | boolean | null,
+  castType: string
+): CastExpressionNode => ({
+  type: 'Cast',
+  expression: toOperand(expression),
+  castType
+});
+
 /**
  * Creates an EXISTS expression
  * @param subquery - Subquery to check for existence

package/src/core/ast/expression-nodes.ts

@@ -95,6 +95,19 @@ export interface CaseExpressionNode {
   alias?: string;
 }
 
+/**
+ * AST node representing a CAST expression (CAST(value AS type)).
+ */
+export interface CastExpressionNode {
+  type: 'Cast';
+  /** Expression being cast */
+  expression: OperandNode;
+  /** SQL type literal, e.g. "varchar(255)" */
+  castType: string;
+  /** Optional alias for the result */
+  alias?: string;
+}
+
 /**
  * AST node representing a window function
  */
@@ -133,7 +146,9 @@ export type OperandNode =
   | JsonPathNode
   | ScalarSubqueryNode
   | CaseExpressionNode
-  | WindowFunctionNode;
+  | CastExpressionNode
+  | WindowFunctionNode
+  | ArithmeticExpressionNode;
 
 const operandTypes = new Set<OperandNode['type']>([
   'AliasRef',
@@ -143,7 +158,9 @@ const operandTypes = new Set<OperandNode['type']>([
   'JsonPath',
   'ScalarSubquery',
   'CaseExpression',
-  'WindowFunction'
+  'Cast',
+  'WindowFunction',
+  'ArithmeticExpression'
 ]);
 
 const hasTypeProperty = (value: unknown): value is { type?: string } =>
@@ -158,12 +175,15 @@ export const isFunctionNode = (node: unknown): node is FunctionNode =>
   isOperandNode(node) && node.type === 'Function';
 export const isCaseExpressionNode = (node: unknown): node is CaseExpressionNode =>
   isOperandNode(node) && node.type === 'CaseExpression';
+
+export const isCastExpressionNode = (node: unknown): node is CastExpressionNode =>
+  isOperandNode(node) && node.type === 'Cast';
 export const isWindowFunctionNode = (node: unknown): node is WindowFunctionNode =>
   isOperandNode(node) && node.type === 'WindowFunction';
 export const isExpressionSelectionNode = (
-  node: ColumnRef | FunctionNode | CaseExpressionNode | WindowFunctionNode
-): node is FunctionNode | CaseExpressionNode | WindowFunctionNode =>
-  isFunctionNode(node) || isCaseExpressionNode(node) || isWindowFunctionNode(node);
+  node: ColumnRef | FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode
+): node is FunctionNode | CaseExpressionNode | CastExpressionNode | WindowFunctionNode =>
+  isFunctionNode(node) || isCaseExpressionNode(node) || isCastExpressionNode(node) || isWindowFunctionNode(node);
 
 /**
  * AST node representing a binary expression (e.g., column = value)

package/src/core/ast/expression-visitor.ts

@@ -14,6 +14,7 @@ import {
   JsonPathNode,
   ScalarSubqueryNode,
   CaseExpressionNode,
+  CastExpressionNode,
   WindowFunctionNode,
   AliasRefNode
 } from './expression-nodes.js';
@@ -42,6 +43,7 @@ export interface OperandVisitor<R> {
   visitJsonPath?(node: JsonPathNode): R;
   visitScalarSubquery?(node: ScalarSubqueryNode): R;
   visitCaseExpression?(node: CaseExpressionNode): R;
+  visitCast?(node: CastExpressionNode): R;
   visitWindowFunction?(node: WindowFunctionNode): R;
   visitAliasRef?(node: AliasRefNode): R;
   otherwise?(node: OperandNode): R;
@@ -196,6 +198,9 @@ export const visitOperand = <R>(node: OperandNode, visitor: OperandVisitor<R>):
     case 'AliasRef':
       if (visitor.visitAliasRef) return visitor.visitAliasRef(node);
       break;
+    case 'Cast':
+      if (visitor.visitCast) return visitor.visitCast(node);
+      break;
     default:
       break;
   }

package/src/core/ast/query.ts

@@ -1,6 +1,7 @@
 import {
   AliasRefNode,
   CaseExpressionNode,
+  CastExpressionNode,
   ColumnNode,
   ExpressionNode,
   FunctionNode,
@@ -121,7 +122,14 @@ export interface SelectQueryNode {
   /** FROM clause table (either a Table or a FunctionTable) */
   from: TableSourceNode;
   /** SELECT clause columns */
-  columns: (ColumnNode | FunctionNode | ScalarSubqueryNode | CaseExpressionNode | WindowFunctionNode)[];
+  columns: (
+    ColumnNode |
+    FunctionNode |
+    ScalarSubqueryNode |
+    CaseExpressionNode |
+    CastExpressionNode |
+    WindowFunctionNode
+  )[];
   /** JOIN clauses */
   joins: JoinNode[];
   /** Optional WHERE clause */

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

@@ -1,6 +1,6 @@
 import { SchemaDialect, DialectName } from '../schema-dialect.js';
 import { formatLiteral, quoteQualified, LiteralFormatter } from '../sql-writing.js';
-import { ColumnDef, ForeignKeyReference } from '../../../schema/column.js';
+import { ColumnDef, ForeignKeyReference } from '../../../schema/column-types.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
 import { DatabaseTable, DatabaseColumn, ColumnDiff } from '../schema-types.js';
 
@@ -93,3 +93,4 @@ export abstract class BaseSchemaDialect implements SchemaDialect {
     return false;
   }
 }
+

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

@@ -1,7 +1,7 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
 import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef } from '../../../schema/column.js';
+import { ColumnDef, normalizeColumnType, renderTypeWithArgs } from '../../../schema/column-types.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
 import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
 import { DialectName } from '../schema-dialect.js';
@@ -24,54 +24,43 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
   }
 
   renderColumnType(column: ColumnDef): string {
-    switch (column.type) {
-      case 'INT':
-      case 'INTEGER':
+    const override = column.dialectTypes?.[this.name] ?? column.dialectTypes?.default;
+    if (override) {
+      return renderTypeWithArgs(override, column.args);
+    }
+
+    const type = normalizeColumnType(column.type);
+    switch (type) {
       case 'int':
       case 'integer':
         return 'INT';
-      case 'BIGINT':
       case 'bigint':
         return 'BIGINT';
-      case 'UUID':
       case 'uuid':
         return 'UNIQUEIDENTIFIER';
-      case 'BOOLEAN':
       case 'boolean':
         return 'BIT';
-      case 'JSON':
       case 'json':
         return 'NVARCHAR(MAX)';
-      case 'DECIMAL':
       case 'decimal':
         return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : 'DECIMAL(18,0)';
-      case 'FLOAT':
       case 'float':
-      case 'DOUBLE':
       case 'double':
         return 'FLOAT';
-      case 'TIMESTAMPTZ':
       case 'timestamptz':
-      case 'TIMESTAMP':
       case 'timestamp':
-      case 'DATETIME':
       case 'datetime':
         return 'DATETIME2';
-      case 'DATE':
       case 'date':
         return 'DATE';
-      case 'VARCHAR':
       case 'varchar':
         return column.args?.length ? `NVARCHAR(${column.args[0]})` : 'NVARCHAR(255)';
-      case 'TEXT':
       case 'text':
         return 'NVARCHAR(MAX)';
-      case 'BINARY':
       case 'binary': {
         const length = column.args?.[0];
         return length !== undefined ? `BINARY(${length})` : 'BINARY(255)';
       }
-      case 'VARBINARY':
       case 'varbinary': {
         const length = column.args?.[0];
         if (typeof length === 'string' && length.toLowerCase() === 'max') {
@@ -79,16 +68,13 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
         }
         return length !== undefined ? `VARBINARY(${length})` : 'VARBINARY(255)';
       }
-      case 'BLOB':
       case 'blob':
-      case 'BYTEA':
       case 'bytea':
         return 'VARBINARY(MAX)';
-      case 'ENUM':
       case 'enum':
         return 'NVARCHAR(255)';
       default:
-        return String(column.type).toUpperCase();
+        return renderTypeWithArgs(String(type).toUpperCase(), column.args);
     }
   }
 
@@ -142,3 +128,4 @@ export class MSSqlSchemaDialect extends BaseSchemaDialect {
     return undefined;
   }
 }
+

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

@@ -1,7 +1,7 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
 import { renderIndexColumns, escapeSqlString, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef } from '../../../schema/column.js';
+import { ColumnDef, normalizeColumnType, renderTypeWithArgs } from '../../../schema/column-types.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
 import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
 import { renderColumnDefinition } from '../schema-generator.js';
@@ -25,69 +25,54 @@ export class MySqlSchemaDialect extends BaseSchemaDialect {
   }
 
   renderColumnType(column: ColumnDef): string {
-    switch (column.type) {
-      case 'INT':
-      case 'INTEGER':
+    const override = column.dialectTypes?.[this.name] ?? column.dialectTypes?.default;
+    if (override) {
+      return renderTypeWithArgs(override, column.args);
+    }
+
+    const type = normalizeColumnType(column.type);
+    switch (type) {
       case 'int':
       case 'integer':
         return 'INT';
-      case 'BIGINT':
       case 'bigint':
         return 'BIGINT';
-      case 'UUID':
       case 'uuid':
         return 'CHAR(36)';
-      case 'BOOLEAN':
       case 'boolean':
         return 'TINYINT(1)';
-      case 'JSON':
       case 'json':
         return 'JSON';
-      case 'DECIMAL':
       case 'decimal':
         return column.args?.length ? `DECIMAL(${column.args[0]},${column.args[1] ?? 0})` : 'DECIMAL';
-      case 'FLOAT':
       case 'float':
         return column.args?.length ? `FLOAT(${column.args[0]})` : 'FLOAT';
-      case 'DOUBLE':
       case 'double':
         return 'DOUBLE';
-      case 'TIMESTAMPTZ':
       case 'timestamptz':
-        return 'TIMESTAMP';
-      case 'TIMESTAMP':
       case 'timestamp':
         return 'TIMESTAMP';
-      case 'DATETIME':
       case 'datetime':
         return 'DATETIME';
-      case 'DATE':
       case 'date':
         return 'DATE';
-      case 'VARCHAR':
       case 'varchar':
         return column.args?.length ? `VARCHAR(${column.args[0]})` : 'VARCHAR(255)';
-      case 'TEXT':
       case 'text':
         return 'TEXT';
-      case 'BINARY':
       case 'binary':
         return column.args?.length ? `BINARY(${column.args[0]})` : 'BINARY(255)';
-      case 'VARBINARY':
       case 'varbinary':
         return column.args?.length ? `VARBINARY(${column.args[0]})` : 'VARBINARY(255)';
-      case 'BLOB':
       case 'blob':
-      case 'BYTEA':
       case 'bytea':
         return 'BLOB';
-      case 'ENUM':
       case 'enum':
         return column.args && Array.isArray(column.args) && column.args.length
           ? `ENUM(${column.args.map((v: string) => `'${escapeSqlString(v)}'`).join(',')})`
           : 'ENUM';
       default:
-        return String(column.type).toUpperCase();
+        return renderTypeWithArgs(String(type).toUpperCase(), column.args);
     }
   }
 
@@ -132,3 +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

@@ -1,7 +1,7 @@
 import { BaseSchemaDialect } from './base-schema-dialect.js';
 import { deriveIndexName } from '../naming-strategy.js';
 import { renderIndexColumns, createLiteralFormatter } from '../sql-writing.js';
-import { ColumnDef, ForeignKeyReference } from '../../../schema/column.js';
+import { ColumnDef, ForeignKeyReference, normalizeColumnType, renderTypeWithArgs } from '../../../schema/column-types.js';
 import { IndexDef, TableDef } from '../../../schema/table.js';
 import { ColumnDiff, DatabaseColumn, DatabaseTable } from '../schema-types.js';
 import { DialectName } from '../schema-dialect.js';
@@ -24,64 +24,50 @@ export class PostgresSchemaDialect extends BaseSchemaDialect {
   }
 
   renderColumnType(column: ColumnDef): string {
-    switch (column.type) {
-      case 'INT':
-      case 'INTEGER':
+    const override = column.dialectTypes?.[this.name] ?? column.dialectTypes?.default;
+    if (override) {
+      return renderTypeWithArgs(override, column.args);
+    }
+
+    const type = normalizeColumnType(column.type);
+    switch (type) {
       case 'int':
       case 'integer':
         return 'integer';
-      case 'BIGINT':
       case 'bigint':
         return 'bigint';
-      case 'UUID':
       case 'uuid':
         return 'uuid';
-      case 'BOOLEAN':
       case 'boolean':
         return 'boolean';
-      case 'JSON':
       case 'json':
         return 'jsonb';
-      case 'DECIMAL':
       case 'decimal':
         return column.args?.length ? `numeric(${column.args[0]}, ${column.args[1] ?? 0})` : 'numeric';
-      case 'FLOAT':
       case 'float':
-      case 'DOUBLE':
       case 'double':
         return 'double precision';
-      case 'TIMESTAMPTZ':
       case 'timestamptz':
         return 'timestamptz';
-      case 'TIMESTAMP':
       case 'timestamp':
         return 'timestamp';
-      case 'DATE':
       case 'date':
         return 'date';
-      case 'DATETIME':
       case 'datetime':
         return 'timestamp';
-      case 'VARCHAR':
       case 'varchar':
         return column.args?.length ? `varchar(${column.args[0]})` : 'varchar';
-      case 'TEXT':
       case 'text':
         return 'text';
-      case 'ENUM':
       case 'enum':
         return 'text';
-      case 'BINARY':
       case 'binary':
-      case 'VARBINARY':
       case 'varbinary':
-      case 'BLOB':
       case 'blob':
-      case 'BYTEA':
       case 'bytea':
         return 'bytea';
       default:
-        return String(column.type).toLowerCase();
+        return renderTypeWithArgs(String(type).toLowerCase(), column.args);
     }
   }
 
@@ -164,3 +150,4 @@ export class PostgresSchemaDialect extends BaseSchemaDialect {
     return undefined;
   }
 }
+

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

@@ -2,7 +2,7 @@ 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.js';
+import { ForeignKeyReference } from '../../../schema/column-types.js';
 import { createLiteralFormatter } from '../sql-writing.js';
 
 class DummySchemaDialect extends BaseSchemaDialect {
@@ -67,3 +67,4 @@ describe('renderReference deferrable handling', () => {
         expect(sql).not.toContain('DEFERRABLE INITIALLY DEFERRED');
     });
 });
+