metal-orm 1.0.41 → 1.0.43

package/dist/index.js

@@ -32,7 +32,8 @@ var init_schema_plan_executor = __esm({
 // src/schema/table.ts
 var defineTable = (name, columns, relations = {}, hooks, options = {}) => {
   const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
-    acc[key] = { ...def, name: key, table: name };
+    const colDef = { ...def, name: key, table: name };
+    acc[key] = colDef;
     return acc;
   }, {});
   return {
@@ -50,6 +51,65 @@ var defineTable = (name, columns, relations = {}, hooks, options = {}) => {
     collation: options.collation
   };
 };
+var TABLE_REF_CACHE = /* @__PURE__ */ new WeakMap();
+var withColumnProps = (table) => {
+  const cached = TABLE_REF_CACHE.get(table);
+  if (cached) return cached;
+  const proxy = new Proxy(table, {
+    get(target, prop, receiver) {
+      const t = target;
+      if (prop === "$") return t.columns;
+      if (Reflect.has(target, prop)) return Reflect.get(target, prop, receiver);
+      if (typeof prop === "string" && prop in t.columns) return t.columns[prop];
+      return void 0;
+    },
+    has(target, prop) {
+      const t = target;
+      return prop === "$" || Reflect.has(target, prop) || typeof prop === "string" && prop in t.columns;
+    },
+    ownKeys(target) {
+      const t = target;
+      const base = Reflect.ownKeys(target);
+      const cols = Object.keys(t.columns);
+      for (const k of cols) {
+        if (!base.includes(k)) base.push(k);
+      }
+      if (!base.includes("$")) base.push("$");
+      return base;
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (prop === "$") {
+        return {
+          configurable: true,
+          enumerable: false,
+          get() {
+            return target.columns;
+          }
+        };
+      }
+      if (typeof prop === "string" && prop in target.columns && !Reflect.has(target, prop)) {
+        return {
+          configurable: true,
+          enumerable: true,
+          value: target.columns[prop],
+          writable: false
+        };
+      }
+      return Reflect.getOwnPropertyDescriptor(target, prop);
+    }
+  });
+  TABLE_REF_CACHE.set(table, proxy);
+  return proxy;
+};
+var tableRef = (table) => withColumnProps(table);
+function getColumn(table, key) {
+  const col2 = table.columns[key];
+  if (!col2) {
+    const tableName = table.name || "<unknown>";
+    throw new Error(`Column '${key}' does not exist on table '${tableName}'`);
+  }
+  return col2;
+}
 
 // src/schema/column.ts
 var col = {
@@ -254,10 +314,14 @@ var operandTypes = /* @__PURE__ */ new Set([
   "CaseExpression",
   "WindowFunction"
 ]);
-var isOperandNode = (node) => node && operandTypes.has(node.type);
-var isFunctionNode = (node) => node?.type === "Function";
-var isCaseExpressionNode = (node) => node?.type === "CaseExpression";
-var isWindowFunctionNode = (node) => node?.type === "WindowFunction";
+var hasTypeProperty = (value) => typeof value === "object" && value !== null && "type" in value;
+var isOperandNode = (node) => {
+  if (!hasTypeProperty(node)) return false;
+  return operandTypes.has(node.type);
+};
+var isFunctionNode = (node) => isOperandNode(node) && node.type === "Function";
+var isCaseExpressionNode = (node) => isOperandNode(node) && node.type === "CaseExpression";
+var isWindowFunctionNode = (node) => isOperandNode(node) && node.type === "WindowFunction";
 var isExpressionSelectionNode = (node) => isFunctionNode(node) || isCaseExpressionNode(node) || isWindowFunctionNode(node);
 
 // src/core/ast/expression-builders.ts
@@ -547,14 +611,15 @@ var registerOperandDispatcher = (type, dispatcher) => {
 };
 var clearExpressionDispatchers = () => expressionDispatchers.clear();
 var clearOperandDispatchers = () => operandDispatchers.clear();
+var getNodeType = (node) => typeof node === "object" && node !== null && typeof node.type === "string" ? node.type : void 0;
 var unsupportedExpression = (node) => {
-  throw new Error(`Unsupported expression type "${node?.type ?? "unknown"}"`);
+  throw new Error(`Unsupported expression type "${getNodeType(node) ?? "unknown"}"`);
 };
 var unsupportedOperand = (node) => {
-  throw new Error(`Unsupported operand type "${node?.type ?? "unknown"}"`);
+  throw new Error(`Unsupported operand type "${getNodeType(node) ?? "unknown"}"`);
 };
 var visitExpression = (node, visitor) => {
-  const dynamic = expressionDispatchers.get(node?.type);
+  const dynamic = expressionDispatchers.get(node.type);
   if (dynamic) return dynamic(node, visitor);
   switch (node.type) {
     case "BinaryExpression":
@@ -585,7 +650,7 @@ var visitExpression = (node, visitor) => {
   return unsupportedExpression(node);
 };
 var visitOperand = (node, visitor) => {
-  const dynamic = operandDispatchers.get(node?.type);
+  const dynamic = operandDispatchers.get(node.type);
   if (dynamic) return dynamic(node, visitor);
   switch (node.type) {
     case "Column":
@@ -812,7 +877,8 @@ var Dialect = class _Dialect {
     if (!where) return "";
     return ` WHERE ${this.compileExpression(where, ctx)}`;
   }
-  compileReturning(returning, ctx) {
+  compileReturning(returning, _ctx) {
+    void _ctx;
     if (!returning || returning.length === 0) return "";
     throw new Error("RETURNING is not supported by this dialect.");
   }
@@ -860,14 +926,16 @@ var Dialect = class _Dialect {
    * @param index - Parameter index
    * @returns Formatted placeholder string
    */
-  formatPlaceholder(index) {
+  formatPlaceholder(_index) {
+    void _index;
     return "?";
   }
   /**
    * Whether the current dialect supports a given set operation.
    * Override in concrete dialects to restrict support.
    */
-  supportsSetOperation(kind) {
+  supportsSetOperation(_kind) {
+    void _kind;
     return true;
   }
   /**
@@ -1060,15 +1128,22 @@ var Dialect = class _Dialect {
   }
   registerDefaultOperandCompilers() {
     this.registerOperandCompiler("Literal", (literal, ctx) => ctx.addParameter(literal.value));
-    this.registerOperandCompiler("AliasRef", (alias, _ctx) => this.quoteIdentifier(alias.name));
+    this.registerOperandCompiler("AliasRef", (alias, _ctx) => {
+      void _ctx;
+      return this.quoteIdentifier(alias.name);
+    });
     this.registerOperandCompiler("Column", (column, _ctx) => {
+      void _ctx;
       return `${this.quoteIdentifier(column.table)}.${this.quoteIdentifier(column.name)}`;
     });
     this.registerOperandCompiler(
       "Function",
       (fnNode, ctx) => this.compileFunctionOperand(fnNode, ctx)
     );
-    this.registerOperandCompiler("JsonPath", (path, _ctx) => this.compileJsonPath(path));
+    this.registerOperandCompiler("JsonPath", (path, _ctx) => {
+      void _ctx;
+      return this.compileJsonPath(path);
+    });
     this.registerOperandCompiler("ScalarSubquery", (node, ctx) => {
       const sql = this.compileSelectAst(node.query, ctx).trim().replace(/;$/, "");
       return `(${sql})`;
@@ -1112,7 +1187,8 @@ var Dialect = class _Dialect {
     });
   }
   // Default fallback, should be overridden by dialects if supported
-  compileJsonPath(node) {
+  compileJsonPath(_node) {
+    void _node;
     throw new Error("JSON Path not supported by this dialect");
   }
   /**
@@ -1278,6 +1354,7 @@ var NoReturningStrategy = class {
    * @throws Error indicating RETURNING is not supported.
    */
   compileReturning(returning, _ctx) {
+    void _ctx;
     if (!returning || returning.length === 0) return "";
     throw new Error("RETURNING is not supported by this dialect.");
   }
@@ -1679,6 +1756,7 @@ var PostgresDialect = class extends SqlDialectBase {
     return `${col2}->>'${node.path}'`;
   }
   compileReturning(returning, ctx) {
+    void ctx;
     if (!returning || returning.length === 0) return "";
     const columns = this.formatReturningColumns(returning);
     return ` RETURNING ${columns}`;
@@ -1929,9 +2007,11 @@ var SqliteDialect = class extends SqlDialectBase {
     return `json_extract(${col2}, '${node.path}')`;
   }
   compileQualifiedColumn(column, _table) {
+    void _table;
     return this.quoteIdentifier(column.name);
   }
   compileReturning(returning, ctx) {
+    void ctx;
     if (!returning || returning.length === 0) return "";
     const columns = this.formatReturningColumns(returning);
     return ` RETURNING ${columns}`;
@@ -2584,7 +2664,8 @@ var HydrationManager = class _HydrationManager {
   getProjectionNames(columns) {
     const names = [];
     for (const col2 of columns) {
-      const alias = col2.alias ?? col2.name;
+      const node = col2;
+      const alias = node.alias ?? node.name;
       if (!alias) return void 0;
       names.push(alias);
     }
@@ -2801,7 +2882,8 @@ var buildDefaultHydrationPlan = (table) => ({
 // src/query-builder/raw-column-parser.ts
 var parseRawColumn = (col2, tableName, ctes) => {
   if (col2.includes("(")) {
-    const [fn4, rest] = col2.split("(");
+    const [_fn, rest] = col2.split("(");
+    void _fn;
     const colName = rest.replace(")", "");
     const [table, name] = colName.includes(".") ? colName.split(".") : [tableName, colName];
     return { type: "Column", table, name, alias: col2 };
@@ -3000,8 +3082,8 @@ var QueryAstService = class {
   }
   normalizeOrderingTerm(term) {
     const from = this.state.ast.from;
-    const tableRef = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const termType = term?.type;
+    const tableRef2 = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
+    const termType = term.type;
     if (termType === "Column") {
       return term;
     }
@@ -3014,7 +3096,7 @@ var QueryAstService = class {
     if (termType === "BinaryExpression" || termType === "LogicalExpression" || termType === "NullExpression" || termType === "InExpression" || termType === "ExistsExpression" || termType === "BetweenExpression" || termType === "ArithmeticExpression") {
       return term;
     }
-    return buildColumnNode(tableRef, term);
+    return buildColumnNode(tableRef2, term);
   }
 };
 
@@ -3420,8 +3502,8 @@ var ColumnSelector = class {
    */
   distinct(context, columns) {
     const from = context.state.ast.from;
-    const tableRef = from.type === "Table" && from.alias ? { ...this.env.table, alias: from.alias } : this.env.table;
-    const nodes = columns.map((col2) => buildColumnNode(tableRef, col2));
+    const tableRef2 = from.type === "Table" && from.alias ? { ...this.env.table, alias: from.alias } : this.env.table;
+    const nodes = columns.map((col2) => buildColumnNode(tableRef2, col2));
     const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
     const nextState = astService.withDistinct(nodes);
     return { state: nextState, hydration: context.hydration };
@@ -4001,7 +4083,6 @@ var DefaultManyToManyCollection = class {
   }
   async syncByIds(ids) {
     await this.load();
-    const targetKey = this.relation.targetKey || findPrimaryKey(this.relation.target);
     const normalized = new Set(ids.map((id) => toKey5(id)));
     const currentIds = new Set(this.items.map((item) => toKey5(this.extractId(item))));
     for (const id of normalized) {
@@ -4272,7 +4353,6 @@ var createEntityProxy = (ctx, table, row, lazyRelations = []) => {
     enumerable: false,
     writable: false
   });
-  let proxy;
   const handler = {
     get(targetObj, prop, receiver) {
       if (prop === ENTITY_META) {
@@ -4280,7 +4360,7 @@ var createEntityProxy = (ctx, table, row, lazyRelations = []) => {
       }
       if (prop === "$load") {
         return async (relationName) => {
-          const wrapper = getRelationWrapper(meta, relationName, proxy);
+          const wrapper = getRelationWrapper(meta, relationName, receiver);
           if (wrapper && typeof wrapper.load === "function") {
             return wrapper.load();
           }
@@ -4288,19 +4368,19 @@ var createEntityProxy = (ctx, table, row, lazyRelations = []) => {
         };
       }
       if (typeof prop === "string" && table.relations[prop]) {
-        return getRelationWrapper(meta, prop, proxy);
+        return getRelationWrapper(meta, prop, receiver);
       }
       return Reflect.get(targetObj, prop, receiver);
     },
     set(targetObj, prop, value, receiver) {
       const result = Reflect.set(targetObj, prop, value, receiver);
       if (typeof prop === "string" && table.columns[prop]) {
-        ctx.markDirty(proxy);
+        ctx.markDirty(receiver);
       }
       return result;
     }
   };
-  proxy = new Proxy(target, handler);
+  const proxy = new Proxy(target, handler);
   populateHydrationCache(proxy, row, meta);
   return proxy;
 };
@@ -4542,7 +4622,8 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
     return this.clone(nextContext);
   }
   resolveQueryNode(query) {
-    return typeof query.getAST === "function" ? query.getAST() : query;
+    const candidate = query;
+    return typeof candidate.getAST === "function" && candidate.getAST ? candidate.getAST() : query;
   }
   applyCorrelation(ast, correlation) {
     if (!correlation) return ast;
@@ -4811,18 +4892,18 @@ var SelectQueryBuilder = class _SelectQueryBuilder {
    * Selects columns for the root table and relations from a single config object.
    */
   selectColumnsDeep(config) {
-    let qb = this;
+    let currBuilder = this;
     if (config.root?.length) {
-      qb = qb.selectColumns(...config.root);
+      currBuilder = currBuilder.selectColumns(...config.root);
     }
     for (const key of Object.keys(config)) {
       if (key === "root") continue;
       const relName = key;
       const cols = config[relName];
       if (!cols || !cols.length) continue;
-      qb = qb.selectRelationColumns(relName, ...cols);
+      currBuilder = currBuilder.selectRelationColumns(relName, ...cols);
     }
-    return qb;
+    return currBuilder;
   }
   getLazyRelations() {
     return Array.from(this.lazyRelations);
@@ -5257,6 +5338,13 @@ var selectFromEntity = (ctor) => {
   }
   return new SelectQueryBuilder(table);
 };
+var entityRef = (ctor) => {
+  const table = getTableDefFromEntity(ctor);
+  if (!table) {
+    throw new Error(`Entity '${ctor.name}' is not registered with decorators or has not been bootstrapped`);
+  }
+  return tableRef(table);
+};
 
 // src/query-builder/select-helpers.ts
 function sel(table, ...cols) {
@@ -5409,11 +5497,13 @@ var InsertQueryBuilder = class _InsertQueryBuilder {
     return columns.map((column) => buildColumnNode(this.table, column));
   }
   resolveSelectQuery(query) {
-    return typeof query.getAST === "function" ? query.getAST() : query;
+    const candidate = query;
+    return typeof candidate.getAST === "function" && candidate.getAST ? candidate.getAST() : query;
   }
   compile(arg) {
-    if (typeof arg.compileInsert === "function") {
-      return arg.compileInsert(this.state.ast);
+    const candidate = arg;
+    if (typeof candidate.compileInsert === "function") {
+      return candidate.compileInsert(this.state.ast);
     }
     const dialect = resolveDialectInput(arg);
     return dialect.compileInsert(this.state.ast);
@@ -5550,8 +5640,9 @@ var UpdateQueryBuilder = class _UpdateQueryBuilder {
     return this.resolveTableSource(table);
   }
   compile(arg) {
-    if (typeof arg.compileUpdate === "function") {
-      return arg.compileUpdate(this.state.ast);
+    const candidate = arg;
+    if (typeof candidate.compileUpdate === "function") {
+      return candidate.compileUpdate(this.state.ast);
     }
     const dialect = resolveDialectInput(arg);
     return dialect.compileUpdate(this.state.ast);
@@ -5652,8 +5743,9 @@ var DeleteQueryBuilder = class _DeleteQueryBuilder {
     return this.resolveTableSource(table);
   }
   compile(arg) {
-    if (typeof arg.compileDelete === "function") {
-      return arg.compileDelete(this.state.ast);
+    const candidate = arg;
+    if (typeof candidate.compileDelete === "function") {
+      return candidate.compileDelete(this.state.ast);
     }
     const dialect = resolveDialectInput(arg);
     return dialect.compileDelete(this.state.ast);
@@ -5703,7 +5795,7 @@ var generateCreateTableSql = (table, dialect) => {
   const pk = resolvePrimaryKey(table);
   const inlinePkColumns = /* @__PURE__ */ new Set();
   const columnLines = Object.values(table.columns).map((col2) => {
-    const includePk = dialect.preferInlinePkAutoincrement?.(col2, table, pk) && pk.includes(col2.name);
+    const includePk = dialect.preferInlinePkAutoincrement(col2, table, pk) && pk.includes(col2.name);
     if (includePk) {
       inlinePkColumns.add(col2.name);
     }
@@ -6208,7 +6300,7 @@ var postgresIntrospector = {
       ],
       where: and(
         eq({ table: "ns", name: "nspname" }, schema),
-        eq({ table: "i", name: "indisprimary" }, { type: "Literal", value: false })
+        eq({ table: "i", name: "indisprimary" }, false)
       )
     };
     const indexQueryRows = await runSelectNode(indexQuery, ctx);
@@ -6372,6 +6464,14 @@ var mysqlIntrospector = {
 };
 
 // src/core/ddl/introspect/sqlite.ts
+var toReferentialAction = (value) => {
+  if (!value) return void 0;
+  const normalized = value.toUpperCase();
+  if (normalized === "NO ACTION" || normalized === "RESTRICT" || normalized === "CASCADE" || normalized === "SET NULL" || normalized === "SET DEFAULT") {
+    return normalized;
+  }
+  return void 0;
+};
 var escapeSingleQuotes = (name) => name.replace(/'/g, "''");
 var sqliteIntrospector = {
   async introspect(ctx, options) {
@@ -6405,8 +6505,8 @@ var sqliteIntrospector = {
           col2.references = {
             table: fk.table,
             column: fk.to,
-            onDelete: fk.on_delete?.toUpperCase(),
-            onUpdate: fk.on_update?.toUpperCase()
+            onDelete: toReferentialAction(fk.on_delete),
+            onUpdate: toReferentialAction(fk.on_update)
           };
         }
       });
@@ -6816,11 +6916,7 @@ var TypeScriptGenerator = class {
     const lines = [];
     const hydration = ast.meta?.hydration;
     const hydratedRelations = new Set(hydration?.relations?.map((r) => r.name) ?? []);
-    const selections = ast.columns.filter((col2) => !(hydration && isRelationAlias(col2.alias))).map((col2) => {
-      const key = col2.alias || col2.name;
-      const operand = col2;
-      return `${key}: ${this.printOperand(operand)}`;
-    });
+    const selections = ast.columns.filter((col2) => !(hydration && isRelationAlias(col2.alias))).map((col2, index) => `${this.getSelectionKey(col2, index)}: ${this.printOperand(col2)}`);
     lines.push(`db.select({`);
     selections.forEach((sel2, index) => {
       lines.push(`  ${sel2}${index < selections.length - 1 ? "," : ""}`);
@@ -6908,7 +7004,7 @@ var TypeScriptGenerator = class {
    * Prints an ordering term (operand/expression/alias) to TypeScript code.
    */
   printOrderingTerm(term) {
-    if (!term || !term.type) {
+    if (!term || !("type" in term)) {
       throw new Error("Unsupported ordering term");
     }
     switch (term.type) {
@@ -6927,6 +7023,18 @@ var TypeScriptGenerator = class {
         return this.printExpression(term);
     }
   }
+  getSelectionKey(selection, index) {
+    if (selection.alias) {
+      return selection.alias;
+    }
+    if (this.isNamedSelection(selection)) {
+      return selection.name;
+    }
+    return `selection${index + 1}`;
+  }
+  isNamedSelection(selection) {
+    return "name" in selection;
+  }
   visitBinaryExpression(binary) {
     return this.printBinaryExpression(binary);
   }
@@ -7710,6 +7818,7 @@ var RelationChangeProcessor = class {
    * @param _entry - The relation change entry (reserved for future use)
    */
   async handleBelongsToChange(_entry) {
+    void _entry;
   }
   /**
    * Handles changes for belongs-to-many relations.
@@ -7823,7 +7932,7 @@ var RelationChangeProcessor = class {
     const key = findPrimaryKey(table);
     const value = entity[key];
     if (value === void 0 || value === null) return null;
-    return value;
+    return value ?? null;
   }
 };
 
@@ -8415,8 +8524,6 @@ var Orm = class {
     const session = new OrmSession({ orm: this, executor });
     try {
       return await session.transaction(() => fn4(session));
-    } catch (err) {
-      throw err;
     } finally {
       await session.dispose();
     }
@@ -8447,9 +8554,6 @@ var getOrCreateMetadataBag = (context) => {
 var readMetadataBag = (context) => {
   return context.metadata?.[METADATA_KEY];
 };
-var registerInitializer = (context, initializer) => {
-  context.addInitializer?.(initializer);
-};
 
 // src/decorators/entity.ts
 var toSnakeCase = (value) => {
@@ -8479,14 +8583,24 @@ function Entity(options = {}) {
       if (bag) {
         const meta = ensureEntityMetadata(ctor);
         for (const entry of bag.columns) {
-          if (!meta.columns[entry.propertyName]) {
-            addColumnMetadata(ctor, entry.propertyName, { ...entry.column });
+          if (meta.columns[entry.propertyName]) {
+            throw new Error(
+              `Column '${entry.propertyName}' is already defined on entity '${ctor.name}'.`
+            );
           }
+          addColumnMetadata(ctor, entry.propertyName, { ...entry.column });
         }
         for (const entry of bag.relations) {
-          if (!meta.relations[entry.propertyName]) {
-            addRelationMetadata(ctor, entry.propertyName, entry.relation);
+          if (meta.relations[entry.propertyName]) {
+            throw new Error(
+              `Relation '${entry.propertyName}' is already defined on entity '${ctor.name}'.`
+            );
           }
+          const relationCopy = entry.relation.kind === RelationKinds.BelongsToMany ? {
+            ...entry.relation,
+            defaultPivotColumns: entry.relation.defaultPivotColumns ? [...entry.relation.defaultPivotColumns] : void 0
+          } : { ...entry.relation };
+          addRelationMetadata(ctor, entry.propertyName, relationCopy);
         }
       }
     }
@@ -8549,13 +8663,6 @@ var registerColumnFromContext = (context, column) => {
   if (!bag.columns.some((entry) => entry.propertyName === propertyName)) {
     bag.columns.push({ propertyName, column: { ...column } });
   }
-  registerInitializer(context, function() {
-    const ctor = resolveConstructor(this);
-    if (!ctor) {
-      return;
-    }
-    registerColumn(ctor, propertyName, column);
-  });
 };
 function Column(definition) {
   const normalized = normalizeColumnInput(definition);
@@ -8611,13 +8718,6 @@ var createFieldDecorator = (metadataFactory) => {
       if (!bag.relations.some((entry) => entry.propertyName === propertyName2)) {
         bag.relations.push({ propertyName: propertyName2, relation: relationMetadata });
       }
-      registerInitializer(ctx, function() {
-        const ctor2 = resolveConstructor2(this);
-        if (!ctor2) {
-          return;
-        }
-        registerRelation(ctor2, propertyName2, relationMetadata);
-      });
       return;
     }
     const propertyName = normalizePropertyName2(propertyKeyOrContext);
@@ -9282,6 +9382,7 @@ export {
   diffSchema,
   div,
   endOfMonth,
+  entityRef,
   eq,
   esel,
   executeHydrated,
@@ -9294,6 +9395,7 @@ export {
   fromUnixTime,
   generateCreateTableSql,
   generateSchemaSql,
+  getColumn,
   getSchemaIntrospector,
   getTableDefFromEntity,
   groupConcat,
@@ -9380,6 +9482,7 @@ export {
   substr,
   sum,
   synchronizeSchema,
+  tableRef,
   tan,
   toColumnRef,
   toTableRef,