metal-orm 1.1.7 → 1.1.8

package/package.json

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

package/scripts/generate-entities/schema.mjs

@@ -1,203 +1,204 @@
-import { detectTreeTable, mapTreeTables } from './tree-detection.mjs';
-
-const normalizeName = name => (typeof name === 'string' && name.includes('.') ? name.split('.').pop() : name);
-
-export const mapRelations = (tables, naming) => {
-  const relationMap = new Map();
-  const relationKeys = new Map();
-  const fkIndex = new Map();
-  const uniqueSingleColumns = new Map();
-
-  for (const table of tables) {
-    relationMap.set(table.name, []);
-    relationKeys.set(table.name, new Set());
-    for (const col of table.columns) {
-      if (col.references) {
-        const list = fkIndex.get(table.name) || [];
-        list.push(col);
-        fkIndex.set(table.name, list);
-      }
-    }
-
-    const uniqueCols = new Set();
-    if (Array.isArray(table.primaryKey) && table.primaryKey.length === 1) {
-      uniqueCols.add(table.primaryKey[0]);
-    }
-    for (const col of table.columns) {
-      if (col.unique) uniqueCols.add(col.name);
-    }
-    for (const idx of table.indexes || []) {
-      if (!idx?.unique) continue;
-      if (!Array.isArray(idx.columns) || idx.columns.length !== 1 || !idx.columns[0]?.column) continue;
-      const columnName = idx.columns[0].column;
-      if (idx.where) {
-        const predicate = String(idx.where);
-        const isNotNullOnly = new RegExp(`\\b${columnName}\\b\\s+is\\s+not\\s+null\\b`, 'i').test(predicate);
-        if (!isNotNullOnly) continue;
-      }
-      uniqueCols.add(columnName);
-    }
-    uniqueSingleColumns.set(table.name, uniqueCols);
-  }
-
-  const findTable = name => {
-    const norm = normalizeName(name);
-    return tables.find(t => t.name === name || t.name === norm);
-  };
-
+import { detectTreeTable, mapTreeTables } from './tree-detection.mjs';
+
+const normalizeName = name => (typeof name === 'string' && name.includes('.') ? name.split('.').pop() : name);
+
+export const mapRelations = (tables, naming) => {
+  const relationMap = new Map();
+  const relationKeys = new Map();
+  const fkIndex = new Map();
+  const uniqueSingleColumns = new Map();
+
+  for (const table of tables) {
+    relationMap.set(table.name, []);
+    relationKeys.set(table.name, new Set());
+    for (const col of table.columns) {
+      if (col.references) {
+        const list = fkIndex.get(table.name) || [];
+        list.push(col);
+        fkIndex.set(table.name, list);
+      }
+    }
+
+    const uniqueCols = new Set();
+    if (Array.isArray(table.primaryKey) && table.primaryKey.length === 1) {
+      uniqueCols.add(table.primaryKey[0]);
+    }
+    for (const col of table.columns) {
+      if (col.unique) uniqueCols.add(col.name);
+    }
+    for (const idx of table.indexes || []) {
+      if (!idx?.unique) continue;
+      if (!Array.isArray(idx.columns) || idx.columns.length !== 1 || !idx.columns[0]?.column) continue;
+      const columnName = idx.columns[0].column;
+      if (idx.where) {
+        const predicate = String(idx.where);
+        const isNotNullOnly = new RegExp(`\\b${columnName}\\b\\s+is\\s+not\\s+null\\b`, 'i').test(predicate);
+        if (!isNotNullOnly) continue;
+      }
+      uniqueCols.add(columnName);
+    }
+    uniqueSingleColumns.set(table.name, uniqueCols);
+  }
+
+  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 hasSelfReference = fkCols.some(c => normalizeName(c.references.table) === table.name);
     const distinctTargets = Array.from(new Set(fkCols.map(c => normalizeName(c.references.table))));
-    if (fkCols.length === 2 && distinctTargets.length === 2) {
+    if (!hasSelfReference && fkCols.length === 2 && distinctTargets.length === 2) {
       const [a, b] = fkCols;
       pivotTables.add(table.name);
       const targetA = findTable(a.references.table);
       const targetB = findTable(b.references.table);
-      if (targetA && targetB) {
-        const aKey = relationKeys.get(targetA.name);
-        const bKey = relationKeys.get(targetB.name);
-        const aProp = naming.belongsToManyProperty(targetB.name);
-        const bProp = naming.belongsToManyProperty(targetA.name);
-        if (!aKey.has(aProp)) {
-          aKey.add(aProp);
-          relationMap.get(targetA.name)?.push({
-            kind: 'belongsToMany',
-            property: aProp,
-            target: targetB.name,
-            pivotTable: table.name,
-            pivotForeignKeyToRoot: a.name,
-            pivotForeignKeyToTarget: b.name
-          });
-        }
-        if (!bKey.has(bProp)) {
-          bKey.add(bProp);
-          relationMap.get(targetB.name)?.push({
-            kind: 'belongsToMany',
-            property: bProp,
-            target: targetA.name,
-            pivotTable: table.name,
-            pivotForeignKeyToRoot: b.name,
-            pivotForeignKeyToTarget: a.name
-          });
-        }
-      }
-    }
-  }
-
-  for (const table of 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 = targetKey ? relationKeys.get(targetKey) : undefined;
-
-      if (!belongsKey || !hasManyKey) continue;
-
-      const belongsProp = naming.belongsToProperty(fk.name, targetTable);
-      if (!belongsKey.has(belongsProp)) {
-        belongsKey.add(belongsProp);
-        relationMap.get(table.name)?.push({
-          kind: 'belongsTo',
-          property: belongsProp,
-          target: targetTable,
-          foreignKey: fk.name
-        });
-      }
-
-      // Skip generating HasMany/HasOne relations TO pivot tables
-      // (pivot data is accessible via _pivot on BelongsToMany)
-      if (pivotTables.has(table.name)) continue;
-
-      const uniqueCols = uniqueSingleColumns.get(table.name);
-      const isHasOne = Boolean(uniqueCols?.has(fk.name));
-      const relationKind = isHasOne ? 'hasOne' : 'hasMany';
-      const inverseProp = isHasOne ? naming.hasOneProperty(table.name) : naming.hasManyProperty(table.name);
-      if (!hasManyKey.has(inverseProp)) {
-        hasManyKey.add(inverseProp);
-        relationMap.get(targetKey)?.push({
-          kind: relationKind,
-          property: inverseProp,
-          target: table.name,
-          foreignKey: fk.name
-        });
-      }
-    }
-  }
-
-  return relationMap;
-};
-
-export const buildSchemaMetadata = (schema, naming) => {
-  const tables = schema.tables.map(t => {
-    const indexes = Array.isArray(t.indexes) ? t.indexes.map(idx => ({ ...idx })) : [];
-    const uniqueSingleColumns = new Set(
-      indexes
-        .filter(idx => idx?.unique && !idx?.where && Array.isArray(idx.columns) && idx.columns.length === 1)
-        .map(idx => idx.columns[0]?.column)
-        .filter(Boolean)
-    );
-
-    return {
-      name: t.name,
-      schema: t.schema,
-      columns: (t.columns || []).map(col => {
-        const unique = col.unique !== undefined ? col.unique : uniqueSingleColumns.has(col.name) ? true : undefined;
-        return { ...col, unique };
-      }),
-      primaryKey: t.primaryKey || [],
-      indexes,
-      isView: false
-    };
-  });
-
-  const views = (schema.views || []).map(v => ({
-    name: v.name,
-    schema: v.schema,
-    columns: (v.columns || []).map(col => ({ ...col })),
-    primaryKey: [],
-    indexes: [],
-    isView: true,
-    definition: v.definition,
-    comment: v.comment
-  }));
-
-  const allEntities = [...tables, ...views];
-
-  const classNames = new Map();
-  allEntities.forEach(t => {
-    const className = naming.classNameFromTable(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, naming);
-  
-  // Detect tree tables
-  const treeConfigs = mapTreeTables(tables, naming);
-
-  return {
-    tables,
-    views,
-    classNames,
-    relations,
-    resolveClassName,
-    treeConfigs
-  };
-};
+      if (targetA && targetB) {
+        const aKey = relationKeys.get(targetA.name);
+        const bKey = relationKeys.get(targetB.name);
+        const aProp = naming.belongsToManyProperty(targetB.name);
+        const bProp = naming.belongsToManyProperty(targetA.name);
+        if (!aKey.has(aProp)) {
+          aKey.add(aProp);
+          relationMap.get(targetA.name)?.push({
+            kind: 'belongsToMany',
+            property: aProp,
+            target: targetB.name,
+            pivotTable: table.name,
+            pivotForeignKeyToRoot: a.name,
+            pivotForeignKeyToTarget: b.name
+          });
+        }
+        if (!bKey.has(bProp)) {
+          bKey.add(bProp);
+          relationMap.get(targetB.name)?.push({
+            kind: 'belongsToMany',
+            property: bProp,
+            target: targetA.name,
+            pivotTable: table.name,
+            pivotForeignKeyToRoot: b.name,
+            pivotForeignKeyToTarget: a.name
+          });
+        }
+      }
+    }
+  }
+
+  for (const table of 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 = targetKey ? relationKeys.get(targetKey) : undefined;
+
+      if (!belongsKey || !hasManyKey) continue;
+
+      const belongsProp = naming.belongsToProperty(fk.name, targetTable);
+      if (!belongsKey.has(belongsProp)) {
+        belongsKey.add(belongsProp);
+        relationMap.get(table.name)?.push({
+          kind: 'belongsTo',
+          property: belongsProp,
+          target: targetTable,
+          foreignKey: fk.name
+        });
+      }
+
+      // Skip generating HasMany/HasOne relations TO pivot tables
+      // (pivot data is accessible via _pivot on BelongsToMany)
+      if (pivotTables.has(table.name)) continue;
+
+      const uniqueCols = uniqueSingleColumns.get(table.name);
+      const isHasOne = Boolean(uniqueCols?.has(fk.name));
+      const relationKind = isHasOne ? 'hasOne' : 'hasMany';
+      const inverseProp = isHasOne ? naming.hasOneProperty(table.name) : naming.hasManyProperty(table.name);
+      if (!hasManyKey.has(inverseProp)) {
+        hasManyKey.add(inverseProp);
+        relationMap.get(targetKey)?.push({
+          kind: relationKind,
+          property: inverseProp,
+          target: table.name,
+          foreignKey: fk.name
+        });
+      }
+    }
+  }
+
+  return relationMap;
+};
+
+export const buildSchemaMetadata = (schema, naming) => {
+  const tables = schema.tables.map(t => {
+    const indexes = Array.isArray(t.indexes) ? t.indexes.map(idx => ({ ...idx })) : [];
+    const uniqueSingleColumns = new Set(
+      indexes
+        .filter(idx => idx?.unique && !idx?.where && Array.isArray(idx.columns) && idx.columns.length === 1)
+        .map(idx => idx.columns[0]?.column)
+        .filter(Boolean)
+    );
+
+    return {
+      name: t.name,
+      schema: t.schema,
+      columns: (t.columns || []).map(col => {
+        const unique = col.unique !== undefined ? col.unique : uniqueSingleColumns.has(col.name) ? true : undefined;
+        return { ...col, unique };
+      }),
+      primaryKey: t.primaryKey || [],
+      indexes,
+      isView: false
+    };
+  });
+
+  const views = (schema.views || []).map(v => ({
+    name: v.name,
+    schema: v.schema,
+    columns: (v.columns || []).map(col => ({ ...col })),
+    primaryKey: [],
+    indexes: [],
+    isView: true,
+    definition: v.definition,
+    comment: v.comment
+  }));
+
+  const allEntities = [...tables, ...views];
+
+  const classNames = new Map();
+  allEntities.forEach(t => {
+    const className = naming.classNameFromTable(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, naming);
+  
+  // Detect tree tables
+  const treeConfigs = mapTreeTables(tables, naming);
+
+  return {
+    tables,
+    views,
+    classNames,
+    relations,
+    resolveClassName,
+    treeConfigs
+  };
+};

package/src/decorators/decorator-metadata.ts

@@ -1,28 +1,34 @@
-import { ColumnDefLike, RelationMetadata } from '../orm/entity-metadata.js';
-import type { TransformerMetadata } from './transformers/transformer-metadata.js';
-
+import { ColumnDefLike, RelationMetadata } from '../orm/entity-metadata.js';
+import type { TransformerMetadata } from './transformers/transformer-metadata.js';
+
 /**
  * Bag for storing decorator metadata during the decoration phase.
  */
+export interface DecoratorTreeMetadata {
+  parentProperty?: string;
+  childrenProperty?: string;
+}
+
 export interface DecoratorMetadataBag {
   columns: Array<{ propertyName: string; column: ColumnDefLike }>;
   relations: Array<{ propertyName: string; relation: RelationMetadata }>;
   transformers: Array<{ propertyName: string; metadata: TransformerMetadata }>;
+  tree?: DecoratorTreeMetadata;
 }
-
-const METADATA_KEY = 'metal-orm:decorators';
-
-type MetadataCarrier = {
-  metadata?: Record<PropertyKey, unknown>;
-};
-
-/**
- * Gets or creates a metadata bag for the given decorator context.
- * @param context - The decorator context with metadata support.
- * @returns The metadata bag.
- */
-export const getOrCreateMetadataBag = (context: MetadataCarrier): DecoratorMetadataBag => {
-  const metadata = context.metadata || (context.metadata = {} as Record<PropertyKey, unknown>);
+
+const METADATA_KEY = 'metal-orm:decorators';
+
+type MetadataCarrier = {
+  metadata?: Record<PropertyKey, unknown>;
+};
+
+/**
+ * Gets or creates a metadata bag for the given decorator context.
+ * @param context - The decorator context with metadata support.
+ * @returns The metadata bag.
+ */
+export const getOrCreateMetadataBag = (context: MetadataCarrier): DecoratorMetadataBag => {
+  const metadata = context.metadata || (context.metadata = {} as Record<PropertyKey, unknown>);
   let bag = metadata[METADATA_KEY] as DecoratorMetadataBag | undefined;
   if (!bag) {
     bag = { columns: [], relations: [], transformers: [] };
@@ -30,32 +36,32 @@ export const getOrCreateMetadataBag = (context: MetadataCarrier): DecoratorMetad
   }
   return bag;
 };
-
-/**
- * Reads the metadata bag from the given decorator context.
- * @param context - The decorator context with metadata support.
- * @returns The metadata bag if present.
- */
-export const readMetadataBag = (context: MetadataCarrier): DecoratorMetadataBag | undefined => {
-  return context.metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
-};
-
-/**
- * Reads the metadata bag from a decorated constructor when using standard decorators.
- * @param ctor - The entity constructor.
- * @returns The metadata bag if present.
- */
-export const readMetadataBagFromConstructor = (ctor: object): DecoratorMetadataBag | undefined => {
-  const metadataSymbol = (Symbol as { metadata?: symbol }).metadata;
-  if (!metadataSymbol) return undefined;
-  const metadata = Reflect.get(ctor, metadataSymbol) as Record<PropertyKey, unknown> | undefined;
-  return metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
-};
-
-/**
- * Public helper to read decorator metadata from a class constructor.
- * @param ctor - The entity constructor.
- * @returns The metadata bag if present.
- */
-export const getDecoratorMetadata = (ctor: object): DecoratorMetadataBag | undefined =>
-  readMetadataBagFromConstructor(ctor);
+
+/**
+ * Reads the metadata bag from the given decorator context.
+ * @param context - The decorator context with metadata support.
+ * @returns The metadata bag if present.
+ */
+export const readMetadataBag = (context: MetadataCarrier): DecoratorMetadataBag | undefined => {
+  return context.metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
+};
+
+/**
+ * Reads the metadata bag from a decorated constructor when using standard decorators.
+ * @param ctor - The entity constructor.
+ * @returns The metadata bag if present.
+ */
+export const readMetadataBagFromConstructor = (ctor: object): DecoratorMetadataBag | undefined => {
+  const metadataSymbol = (Symbol as { metadata?: symbol }).metadata;
+  if (!metadataSymbol) return undefined;
+  const metadata = Reflect.get(ctor, metadataSymbol) as Record<PropertyKey, unknown> | undefined;
+  return metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
+};
+
+/**
+ * Public helper to read decorator metadata from a class constructor.
+ * @param ctor - The entity constructor.
+ * @returns The metadata bag if present.
+ */
+export const getDecoratorMetadata = (ctor: object): DecoratorMetadataBag | undefined =>
+  readMetadataBagFromConstructor(ctor);