metal-orm 1.1.7 → 1.1.8

package/src/orm/unit-of-work.ts

@@ -6,8 +6,8 @@ import { UpdateQueryBuilder } from '../query-builder/update.js';
 import { DeleteQueryBuilder } from '../query-builder/delete.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 import type { TableDef, TableHooks } from '../schema/table.js';
-import { payloadResultSets } from '../core/execution/db-executor.js';
-import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
+import { payloadResultSets } from '../core/execution/db-executor.js';
+import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
 import { IdentityMap } from './identity-map.js';
 import { EntityStatus } from './runtime-types.js';
 import type { TrackedEntity } from './runtime-types.js';
@@ -323,10 +323,10 @@ export class UnitOfWork {
    * @param compiled - The compiled query
    * @returns Query results
    */
-  private async executeCompiled(compiled: CompiledQuery): Promise<QueryResult[]> {
-    const payload = await this.executor.executeSql(compiled.sql, compiled.params);
-    return payloadResultSets(payload);
-  }
+  private async executeCompiled(compiled: CompiledQuery): Promise<QueryResult[]> {
+    const payload = await this.executor.executeSql(compiled.sql, compiled.params);
+    return payloadResultSets(payload);
+  }
 
   /**
    * Gets columns for RETURNING clause.

package/src/tree/tree-decorator.ts

@@ -5,8 +5,16 @@
  * Integrates with MetalORM's decorator entity system.
  */
 
-import type { TreeConfig } from './tree-types.js';
-import { resolveTreeConfig } from './tree-types.js';
+import type { TreeConfig } from './tree-types.js';
+import { resolveTreeConfig } from './tree-types.js';
+import { RelationKinds, belongsTo, hasMany } from '../schema/relation.js';
+import { addRelationMetadata, getEntityMetadata, type EntityConstructor } from '../orm/entity-metadata.js';
+import {
+  type DecoratorTreeMetadata,
+  getOrCreateMetadataBag,
+  readMetadataBag,
+  readMetadataBagFromConstructor
+} from '../decorators/decorator-metadata.js';
 
 /**
  * Symbol key for storing tree metadata on entity classes.
@@ -73,18 +81,25 @@ export interface TreeDecoratorOptions {
  * }
  * ```
  */
-export function Tree(options: TreeDecoratorOptions = {}) {
-  return function <T extends abstract new (...args: unknown[]) => object>(
-    target: T
-  ): T {
-    const config = resolveTreeConfig(options);
-    const metadata: TreeMetadata = { config };
-    
-    setTreeMetadataOnClass(target, metadata);
-    
-    return target;
-  };
-}
+export function Tree(options: TreeDecoratorOptions = {}) {
+  return function <T extends abstract new (...args: unknown[]) => object>(
+    target: T,
+    context: ClassDecoratorContext<T>
+  ): T {
+    const config = resolveTreeConfig(options);
+    const metadataBag = readMetadataBag(context) ?? readMetadataBagFromConstructor(target);
+    const metadata: TreeMetadata = {
+      config,
+      parentProperty: metadataBag?.tree?.parentProperty,
+      childrenProperty: metadataBag?.tree?.childrenProperty
+    };
+    
+    setTreeMetadataOnClass(target, metadata);
+    registerTreeRelations(target as unknown as EntityConstructor, metadata);
+    
+    return target;
+  };
+}
 
 /**
  * Decorator to mark a property as the parent relation in a tree entity.
@@ -95,23 +110,22 @@ export function Tree(options: TreeDecoratorOptions = {}) {
  * parent?: Category;
  * ```
  */
-export function TreeParent() {
-  return function <T, V>(
-    _value: undefined,
-    context: ClassFieldDecoratorContext<T, V>
-  ): void {
-    const propertyName = String(context.name);
-    
-    context.addInitializer(function (this: T) {
-      const constructor = (this as object).constructor as new (...args: unknown[]) => object;
-      const metadata = getTreeMetadata(constructor);
-      if (metadata) {
-        metadata.parentProperty = propertyName;
-        setTreeMetadata(constructor, metadata);
-      }
-    });
-  };
-}
+export function TreeParent() {
+  return function <T, V>(
+    _value: undefined,
+    context: ClassFieldDecoratorContext<T, V>
+  ): void {
+    if (!context.name) {
+      throw new Error('TreeParent decorator requires a property name');
+    }
+    if (context.private) {
+      throw new Error('TreeParent decorator does not support private fields');
+    }
+    const propertyName = String(context.name);
+    const bag = getOrCreateMetadataBag(context);
+    bag.tree = { ...bag.tree, parentProperty: propertyName };
+  };
+}
 
 /**
  * Decorator to mark a property as the children relation in a tree entity.
@@ -122,23 +136,54 @@ export function TreeParent() {
  * children?: Category[];
  * ```
  */
-export function TreeChildren() {
-  return function <T, V>(
-    _value: undefined,
-    context: ClassFieldDecoratorContext<T, V>
-  ): void {
-    const propertyName = String(context.name);
-    
-    context.addInitializer(function (this: T) {
-      const constructor = (this as object).constructor as new (...args: unknown[]) => object;
-      const metadata = getTreeMetadata(constructor);
-      if (metadata) {
-        metadata.childrenProperty = propertyName;
-        setTreeMetadata(constructor, metadata);
-      }
-    });
-  };
-}
+export function TreeChildren() {
+  return function <T, V>(
+    _value: undefined,
+    context: ClassFieldDecoratorContext<T, V>
+  ): void {
+    if (!context.name) {
+      throw new Error('TreeChildren decorator requires a property name');
+    }
+    if (context.private) {
+      throw new Error('TreeChildren decorator does not support private fields');
+    }
+    const propertyName = String(context.name);
+    const bag = getOrCreateMetadataBag(context);
+    bag.tree = { ...bag.tree, childrenProperty: propertyName };
+  };
+}
+
+/**
+ * Synchronizes tree metadata + self-relations for entities using @Tree decorators.
+ * Safe to call multiple times (idempotent).
+ */
+export function syncTreeEntityMetadata(
+  ctor: EntityConstructor,
+  treeMetadata?: DecoratorTreeMetadata
+): void {
+  const current = getTreeMetadata(ctor);
+  if (!current) return;
+  const metadataBag = readMetadataBagFromConstructor(ctor);
+
+  const nextParentProperty =
+    treeMetadata?.parentProperty ?? metadataBag?.tree?.parentProperty ?? current.parentProperty;
+  const nextChildrenProperty =
+    treeMetadata?.childrenProperty ?? metadataBag?.tree?.childrenProperty ?? current.childrenProperty;
+
+  if (nextParentProperty !== current.parentProperty || nextChildrenProperty !== current.childrenProperty) {
+    setTreeMetadata(ctor, {
+      ...current,
+      parentProperty: nextParentProperty,
+      childrenProperty: nextChildrenProperty
+    });
+  }
+
+  registerTreeRelations(ctor, {
+    ...current,
+    parentProperty: nextParentProperty,
+    childrenProperty: nextChildrenProperty
+  });
+}
 
 /**
  * Gets tree metadata from an entity class.
@@ -152,12 +197,50 @@ export function getTreeMetadata(
 /**
  * Sets tree metadata on an entity class.
  */
-export function setTreeMetadata(
-  target: new (...args: unknown[]) => object,
-  metadata: TreeMetadata
-): void {
-  (target as unknown as Record<symbol, TreeMetadata>)[TREE_METADATA_KEY] = metadata;
-}
+export function setTreeMetadata(
+  target: new (...args: unknown[]) => object,
+  metadata: TreeMetadata
+): void {
+  (target as unknown as Record<symbol, TreeMetadata>)[TREE_METADATA_KEY] = metadata;
+}
+
+const registerTreeRelations = (
+  target: EntityConstructor,
+  metadata: TreeMetadata
+): void => {
+  const entityMeta = getEntityMetadata(target);
+  if (!entityMeta) return;
+
+  if (metadata.parentProperty && !entityMeta.relations[metadata.parentProperty]) {
+    addRelationMetadata(target, metadata.parentProperty, {
+      kind: RelationKinds.BelongsTo,
+      propertyKey: metadata.parentProperty,
+      target: () => target,
+      foreignKey: metadata.config.parentKey
+    });
+    if (entityMeta.table && !entityMeta.table.relations[metadata.parentProperty]) {
+      entityMeta.table.relations[metadata.parentProperty] = belongsTo(
+        entityMeta.table,
+        metadata.config.parentKey
+      );
+    }
+  }
+
+  if (metadata.childrenProperty && !entityMeta.relations[metadata.childrenProperty]) {
+    addRelationMetadata(target, metadata.childrenProperty, {
+      kind: RelationKinds.HasMany,
+      propertyKey: metadata.childrenProperty,
+      target: () => target,
+      foreignKey: metadata.config.parentKey
+    });
+    if (entityMeta.table && !entityMeta.table.relations[metadata.childrenProperty]) {
+      entityMeta.table.relations[metadata.childrenProperty] = hasMany(
+        entityMeta.table,
+        metadata.config.parentKey
+      );
+    }
+  }
+};
 
 /**
  * Sets tree metadata on an entity class (internal, handles abstract classes).