metal-orm 1.0.46 → 1.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.46",
+  "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/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/introspect/catalogs/index.ts

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

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

@@ -0,0 +1,126 @@
+import { defineTable } from '../../../../schema/table.js';
+import { col } from '../../../../schema/column-types.js';
+
+/** Table definitions for SQL Server catalog views used during introspection. */
+export const SysColumns = defineTable(
+  'columns',
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    column_id: col.int(),
+    max_length: col.int(),
+    precision: col.int(),
+    scale: col.int(),
+    is_nullable: col.boolean(),
+    is_identity: col.boolean(),
+    default_object_id: col.int(),
+    user_type_id: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysTables = defineTable(
+  'tables',
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    schema_id: col.int(),
+    is_ms_shipped: col.boolean()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysSchemas = defineTable(
+  'schemas',
+  {
+    schema_id: col.int(),
+    name: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysTypes = defineTable(
+  'types',
+  {
+    user_type_id: col.int(),
+    name: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysIndexes = defineTable(
+  'indexes',
+  {
+    object_id: col.int(),
+    index_id: col.int(),
+    name: col.varchar(255),
+    is_primary_key: col.boolean(),
+    is_unique: col.boolean(),
+    has_filter: col.boolean(),
+    filter_definition: col.varchar(1024),
+    is_hypothetical: col.boolean()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysIndexColumns = defineTable(
+  'index_columns',
+  {
+    object_id: col.int(),
+    index_id: col.int(),
+    column_id: col.int(),
+    key_ordinal: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysForeignKeys = defineTable(
+  'foreign_keys',
+  {
+    object_id: col.int(),
+    name: col.varchar(255),
+    delete_referential_action_desc: col.varchar(64),
+    update_referential_action_desc: col.varchar(64)
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export const SysForeignKeyColumns = defineTable(
+  'foreign_key_columns',
+  {
+    constraint_object_id: col.int(),
+    parent_object_id: col.int(),
+    parent_column_id: col.int(),
+    referenced_object_id: col.int(),
+    referenced_column_id: col.int(),
+    constraint_column_id: col.int()
+  },
+  {},
+  undefined,
+  { schema: 'sys' }
+);
+
+export default {
+  SysColumns,
+  SysTables,
+  SysSchemas,
+  SysTypes,
+  SysIndexes,
+  SysIndexColumns,
+  SysForeignKeys,
+  SysForeignKeyColumns
+};

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

@@ -0,0 +1,89 @@
+import { defineTable } from '../../../../schema/table.js';
+import { col } from '../../../../schema/column-types.js';
+
+const INFORMATION_SCHEMA = 'information_schema';
+
+export const InformationSchemaTables = defineTable(
+  'tables',
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    table_comment: col.varchar(1024)
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export const InformationSchemaColumns = defineTable(
+  'columns',
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    column_type: col.varchar(255),
+    data_type: col.varchar(255),
+    is_nullable: col.varchar(3),
+    column_default: col.varchar(1024),
+    extra: col.varchar(255),
+    column_comment: col.varchar(1024),
+    ordinal_position: col.int()
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export const InformationSchemaKeyColumnUsage = defineTable(
+  'key_column_usage',
+  {
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    column_name: col.varchar(255),
+    ordinal_position: col.int(),
+    referenced_table_schema: col.varchar(255),
+    referenced_table_name: col.varchar(255),
+    referenced_column_name: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export const InformationSchemaReferentialConstraints = defineTable(
+  'referential_constraints',
+  {
+    constraint_schema: col.varchar(255),
+    constraint_name: col.varchar(255),
+    delete_rule: col.varchar(255),
+    update_rule: col.varchar(255)
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export const InformationSchemaStatistics = defineTable(
+  'statistics',
+  {
+    table_schema: col.varchar(255),
+    table_name: col.varchar(255),
+    index_name: col.varchar(255),
+    non_unique: col.int(),
+    column_name: col.varchar(255),
+    seq_in_index: col.int()
+  },
+  {},
+  undefined,
+  { schema: INFORMATION_SCHEMA }
+);
+
+export default {
+  InformationSchemaTables,
+  InformationSchemaColumns,
+  InformationSchemaKeyColumnUsage,
+  InformationSchemaReferentialConstraints,
+  InformationSchemaStatistics
+};

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

@@ -0,0 +1,47 @@
+import { defineTable } from '../../../../schema/table.js';
+import { col } from '../../../../schema/column-types.js';
+
+// SQLite catalogs are limited; most metadata comes from PRAGMAs, but these tables are queryable.
+
+export const SqliteMaster = defineTable(
+  'sqlite_master',
+  {
+    type: col.varchar(255),      // 'table', 'index', 'view', 'trigger'
+    name: col.varchar(255),      // Object name
+    tbl_name: col.varchar(255),  // Table the object belongs to
+    rootpage: col.int(),         // B-tree root page
+    sql: col.varchar(4096)       // Original DDL
+  },
+  {},
+  undefined,
+  { schema: undefined }
+);
+
+export const SqliteSequence = defineTable(
+  'sqlite_sequence',
+  {
+    name: col.varchar(255),  // Table name
+    seq: col.int()           // Last autoincrement value
+  },
+  {},
+  undefined,
+  { schema: undefined }
+);
+
+export const SqliteStat1 = defineTable(
+  'sqlite_stat1',
+  {
+    tbl: col.varchar(255),   // Table name
+    idx: col.varchar(255),   // Index name
+    stat: col.varchar(255)   // Statistics string
+  },
+  {},
+  undefined,
+  { schema: undefined }
+);
+
+export default {
+  SqliteMaster,
+  SqliteSequence,
+  SqliteStat1
+};

package/src/core/ddl/introspect/functions/mssql.ts

@@ -0,0 +1,84 @@
+import { caseWhen, cast, div, eq, inList, valueToOperand, columnOperand, ValueOperandInput } from '../../../ast/expression-builders.js';
+import { isOperandNode } from '../../../ast/expression-nodes.js';
+import type { OperandNode } from '../../../ast/expression.js';
+import type { ColumnRef } from '../../../ast/types.js';
+import { concat, lower } from '../../../functions/text.js';
+
+type OperandInput = OperandNode | ColumnRef | string | number | boolean | null;
+
+const isColumnReference = (value: unknown): value is ColumnRef =>
+  typeof value === 'object' &&
+  value !== null &&
+  !('type' in value) &&
+  'name' in value &&
+  typeof (value as ColumnRef).name === 'string';
+
+const toOperandNode = (value: OperandInput): OperandNode => {
+  if (isOperandNode(value)) return value;
+  if (isColumnReference(value)) return columnOperand(value);
+  return valueToOperand(value as ValueOperandInput);
+};
+
+const fn = (name: string, args: OperandInput[]): OperandNode => ({
+  type: 'Function',
+  name,
+  fn: name,
+  args: args.map(arg => toOperandNode(arg))
+});
+
+const CHAR_TYPES = ['varchar', 'char', 'varbinary', 'binary', 'nvarchar', 'nchar'];
+const DECIMAL_TYPES = ['decimal', 'numeric'];
+
+export const objectDefinition = (objectId: OperandInput): OperandNode => fn('OBJECT_DEFINITION', [objectId]);
+
+export const buildMssqlDataType = (
+  typeName: OperandInput,
+  maxLength: OperandInput,
+  precision: OperandInput,
+  scale: OperandInput
+): OperandNode => {
+  const typeOperand = toOperandNode(typeName);
+  const maxLenOperand = toOperandNode(maxLength);
+  const precisionOperand = toOperandNode(precision);
+  const scaleOperand = toOperandNode(scale);
+  const typeLower = lower(typeOperand);
+
+  const lengthCase = caseWhen(
+    [
+      {
+        when: eq(maxLenOperand, -1),
+        then: 'max'
+      },
+      {
+        when: inList(typeLower, ['nvarchar', 'nchar']),
+        then: cast(div(maxLenOperand, 2), 'varchar(10)')
+      }
+    ],
+    cast(maxLenOperand, 'varchar(10)')
+  );
+
+  const charSuffix = concat('(', lengthCase, ')');
+
+  const decimalSuffix = concat(
+    '(',
+    cast(precisionOperand, 'varchar(10)'),
+    ',',
+    cast(scaleOperand, 'varchar(10)'),
+    ')'
+  );
+
+  const suffix = caseWhen(
+    [
+      { when: inList(typeLower, CHAR_TYPES), then: charSuffix },
+      { when: inList(typeLower, DECIMAL_TYPES), then: decimalSuffix }
+    ],
+    ''
+  );
+
+  return concat(typeLower, suffix);
+};
+
+export default {
+  objectDefinition,
+  buildMssqlDataType
+};