metal-orm 1.0.42 → 1.0.43

package/README.md

@@ -269,6 +269,7 @@ import {
   eq,
   count,
   rowNumber,
+  MySqlDialect,
   sel,
   hydrateRows,
 } from 'metal-orm';
@@ -298,18 +299,24 @@ users.columns.name.notNull = true;
 users.columns.email.unique = true;
 
 // Build a query with relation & window function
+const u = sel(users, 'id', 'name', 'email');
+const p = sel(posts, 'id', 'userId');
+
 const builder = new SelectQueryBuilder(users)
   .select({
-    ...sel(users, 'id', 'name', 'email'),
-    postCount: count(posts.columns.id),
+    ...u,
+    postCount: count(p.id),
     rank: rowNumber(), // window function helper
   })
-  .leftJoin(posts, eq(posts.columns.userId, users.columns.id))
-  .groupBy(users.columns.id, users.columns.name, users.columns.email)
-  .orderBy(count(posts.columns.id), 'DESC')
+  .leftJoin(posts, eq(p.userId, u.id))
+  .groupBy(u.id)
+  .groupBy(u.name)
+  .groupBy(u.email)
+  .orderBy(count(p.id), 'DESC')
   .limit(10)
   .includePick('posts', ['id', 'title', 'createdAt']); // eager relation for hydration
 
+const dialect = new MySqlDialect();
 const { sql, params } = builder.compile(dialect);
 const [rows] = await connection.execute(sql, params);
 
@@ -353,6 +360,7 @@ import {
   MySqlDialect,
   SelectQueryBuilder,
   eq,
+  tableRef,
   createMysqlExecutor,
 } from 'metal-orm';
 
@@ -365,16 +373,19 @@ const orm = new Orm({
   executorFactory: {
     createExecutor: () => executor,
     createTransactionalExecutor: () => executor,
+    dispose: async () => {},
   },
 });
 const session = new OrmSession({ orm, executor });
 
+const u = tableRef(users);
+
 // 2) Load entities with lazy relations
 const [user] = await new SelectQueryBuilder(users)
   .selectColumns('id', 'name', 'email')
   .includeLazy('posts')  // HasMany as a lazy collection
   .includeLazy('roles')  // BelongsToMany as a lazy collection
-  .where(eq(users.columns.id, 1))
+  .where(eq(u.id, 1))
   .execute(session);
 
 // user is an EntityInstance<typeof users>
@@ -422,6 +433,8 @@ import {
   BelongsTo,
   bootstrapEntities,
   selectFromEntity,
+  entityRef,
+  eq,
 } from 'metal-orm';
 
 @Entity()
@@ -472,15 +485,17 @@ const orm = new Orm({
   executorFactory: {
     createExecutor: () => executor,
     createTransactionalExecutor: () => executor,
+    dispose: async () => {},
   },
 });
 const session = new OrmSession({ orm, executor });
 
 // 3) Query starting from the entity class
+const U = entityRef(User);
 const [user] = await selectFromEntity(User)
   .selectColumns('id', 'name')
   .includeLazy('posts')
-  .where(/* same eq()/and() API as before */)
+  .where(eq(U.id, 1))
   .execute(session);
 
 user.posts.add({ title: 'From decorators' });

package/dist/index.cjs

@@ -127,6 +127,7 @@ __export(index_exports, {
   diffSchema: () => diffSchema,
   div: () => div,
   endOfMonth: () => endOfMonth,
+  entityRef: () => entityRef,
   eq: () => eq,
   esel: () => esel,
   executeHydrated: () => executeHydrated,
@@ -139,6 +140,7 @@ __export(index_exports, {
   fromUnixTime: () => fromUnixTime,
   generateCreateTableSql: () => generateCreateTableSql,
   generateSchemaSql: () => generateSchemaSql,
+  getColumn: () => getColumn,
   getSchemaIntrospector: () => getSchemaIntrospector,
   getTableDefFromEntity: () => getTableDefFromEntity,
   groupConcat: () => groupConcat,
@@ -247,7 +249,8 @@ module.exports = __toCommonJS(index_exports);
 // 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 {
@@ -271,17 +274,20 @@ var withColumnProps = (table) => {
   if (cached) return cached;
   const proxy = new Proxy(table, {
     get(target, prop, receiver) {
-      if (prop === "$") return target.columns;
+      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 target.columns) return target.columns[prop];
+      if (typeof prop === "string" && prop in t.columns) return t.columns[prop];
       return void 0;
     },
     has(target, prop) {
-      return prop === "$" || Reflect.has(target, prop) || typeof prop === "string" && prop in target.columns;
+      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(target.columns);
+      const cols = Object.keys(t.columns);
       for (const k of cols) {
         if (!base.includes(k)) base.push(k);
       }
@@ -313,6 +319,14 @@ var withColumnProps = (table) => {
   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 = {
@@ -517,10 +531,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
@@ -810,14 +828,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":
@@ -848,7 +867,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":
@@ -1075,7 +1094,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.");
   }
@@ -1123,14 +1143,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;
   }
   /**
@@ -1323,15 +1345,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})`;
@@ -1375,7 +1404,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");
   }
   /**
@@ -1541,6 +1571,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.");
   }
@@ -1942,6 +1973,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}`;
@@ -2192,9 +2224,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}`;
@@ -2847,7 +2881,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);
     }
@@ -3064,7 +3099,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 };
@@ -3264,7 +3300,7 @@ var QueryAstService = class {
   normalizeOrderingTerm(term) {
     const from = this.state.ast.from;
     const tableRef2 = from.type === "Table" && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const termType = term?.type;
+    const termType = term.type;
     if (termType === "Column") {
       return term;
     }
@@ -4264,7 +4300,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) {
@@ -4535,7 +4570,6 @@ var createEntityProxy = (ctx, table, row, lazyRelations = []) => {
     enumerable: false,
     writable: false
   });
-  let proxy;
   const handler = {
     get(targetObj, prop, receiver) {
       if (prop === ENTITY_META) {
@@ -4543,7 +4577,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();
           }
@@ -4551,19 +4585,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;
 };
@@ -4805,7 +4839,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;
@@ -5074,18 +5109,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);
@@ -5520,6 +5555,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) {
@@ -5672,11 +5714,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);
@@ -5813,8 +5857,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);
@@ -5915,8 +5960,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);
@@ -5966,7 +6012,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);
     }
@@ -6471,7 +6517,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);
@@ -6635,6 +6681,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) {
@@ -6668,8 +6722,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)
           };
         }
       });
@@ -7079,11 +7133,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 ? "," : ""}`);
@@ -7171,7 +7221,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) {
@@ -7190,6 +7240,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);
   }
@@ -7973,6 +8035,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.
@@ -8086,7 +8149,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;
   }
 };
 
@@ -8678,8 +8741,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();
     }
@@ -8710,9 +8771,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) => {
@@ -8742,14 +8800,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);
         }
       }
     }
@@ -8812,13 +8880,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);
@@ -8874,13 +8935,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);
@@ -9546,6 +9600,7 @@ function createPooledExecutorFactory(opts) {
   diffSchema,
   div,
   endOfMonth,
+  entityRef,
   eq,
   esel,
   executeHydrated,
@@ -9558,6 +9613,7 @@ function createPooledExecutorFactory(opts) {
   fromUnixTime,
   generateCreateTableSql,
   generateSchemaSql,
+  getColumn,
   getSchemaIntrospector,
   getTableDefFromEntity,
   groupConcat,