metal-orm 1.0.30 → 1.0.33

package/dist/index.cjs

@@ -5166,17 +5166,124 @@ var metadataMap = /* @__PURE__ */ new Map();
 var getEntityMetadata = (target) => {
   return metadataMap.get(target);
 };
+var getAllEntityMetadata = () => {
+  return Array.from(metadataMap.values());
+};
+var buildTableDef = (meta) => {
+  if (meta.table) {
+    return meta.table;
+  }
+  const columns = Object.entries(meta.columns).reduce((acc, [key, def]) => {
+    acc[key] = {
+      ...def,
+      name: key,
+      table: meta.tableName
+    };
+    return acc;
+  }, {});
+  const table = defineTable(meta.tableName, columns, {}, meta.hooks);
+  meta.table = table;
+  return table;
+};
 
 // src/decorators/bootstrap.ts
+var isTableDef = (value) => {
+  return typeof value === "object" && value !== null && "columns" in value;
+};
+var unwrapTarget = (target) => {
+  if (typeof target === "function" && target.prototype === void 0) {
+    return target();
+  }
+  return target;
+};
+var resolveTableTarget = (target, tableMap) => {
+  const resolved = unwrapTarget(target);
+  if (isTableDef(resolved)) {
+    return resolved;
+  }
+  const table = tableMap.get(resolved);
+  if (!table) {
+    throw new Error(`Entity '${resolved.name}' is not registered with decorators`);
+  }
+  return table;
+};
+var buildRelationDefinitions = (meta, tableMap) => {
+  const relations = {};
+  for (const [name, relation] of Object.entries(meta.relations)) {
+    switch (relation.kind) {
+      case RelationKinds.HasOne: {
+        relations[name] = hasOne(
+          resolveTableTarget(relation.target, tableMap),
+          relation.foreignKey,
+          relation.localKey,
+          relation.cascade
+        );
+        break;
+      }
+      case RelationKinds.HasMany: {
+        relations[name] = hasMany(
+          resolveTableTarget(relation.target, tableMap),
+          relation.foreignKey,
+          relation.localKey,
+          relation.cascade
+        );
+        break;
+      }
+      case RelationKinds.BelongsTo: {
+        relations[name] = belongsTo(
+          resolveTableTarget(relation.target, tableMap),
+          relation.foreignKey,
+          relation.localKey,
+          relation.cascade
+        );
+        break;
+      }
+      case RelationKinds.BelongsToMany: {
+        relations[name] = belongsToMany(
+          resolveTableTarget(relation.target, tableMap),
+          resolveTableTarget(relation.pivotTable, tableMap),
+          {
+            pivotForeignKeyToRoot: relation.pivotForeignKeyToRoot,
+            pivotForeignKeyToTarget: relation.pivotForeignKeyToTarget,
+            localKey: relation.localKey,
+            targetKey: relation.targetKey,
+            pivotPrimaryKey: relation.pivotPrimaryKey,
+            defaultPivotColumns: relation.defaultPivotColumns,
+            cascade: relation.cascade
+          }
+        );
+        break;
+      }
+    }
+  }
+  return relations;
+};
+var bootstrapEntities = () => {
+  const metas = getAllEntityMetadata();
+  const tableMap = /* @__PURE__ */ new Map();
+  for (const meta of metas) {
+    const table = buildTableDef(meta);
+    tableMap.set(meta.target, table);
+  }
+  for (const meta of metas) {
+    const table = meta.table;
+    const relations = buildRelationDefinitions(meta, tableMap);
+    table.relations = relations;
+  }
+  return metas.map((meta) => meta.table);
+};
 var getTableDefFromEntity = (ctor) => {
   const meta = getEntityMetadata(ctor);
   if (!meta) return void 0;
+  if (!meta.table) {
+    bootstrapEntities();
+  }
   return meta.table;
 };
 var selectFromEntity = (ctor) => {
   const table = getTableDefFromEntity(ctor);
   if (!table) {
-    throw new Error("Entity metadata has not been bootstrapped");
+    throw new Error(`Entity '${ctor.name}' is not registered with decorators or has not been bootstrapped`);
   }
   return new SelectQueryBuilder(table);
 };