metal-orm 1.1.9 → 1.1.10

package/src/orm/entity-relations.ts

@@ -1,207 +1,264 @@
-import { TableDef } from '../schema/table.js';
-import { EntityInstance, HasManyCollection, HasOneReference, BelongsToReference, ManyToManyCollection } from '../schema/types.js';
-import { EntityMeta, RelationKey } from './entity-meta.js';
-import { DefaultHasManyCollection } from './relations/has-many.js';
-import { DefaultHasOneReference } from './relations/has-one.js';
-import { DefaultBelongsToReference } from './relations/belongs-to.js';
-import { DefaultManyToManyCollection } from './relations/many-to-many.js';
-import { HasManyRelation, HasOneRelation, BelongsToRelation, BelongsToManyRelation, RelationKinds } from '../schema/relation.js';
-import { loadHasManyRelation, loadHasOneRelation, loadBelongsToRelation, loadBelongsToManyRelation } from './lazy-batch.js';
-import { findPrimaryKey } from '../query-builder/hydration-planner.js';
-import { relationLoaderCache } from './entity-relation-cache.js';
-
-export type RelationEntityFactory = (
-  table: TableDef,
-  row: Record<string, unknown>
-) => EntityInstance<TableDef>;
-
-const proxifyRelationWrapper = <T extends object>(wrapper: T): T => {
-  return new Proxy(wrapper, {
-    get(target, prop, receiver) {
-      if (typeof prop === 'symbol') {
-        return Reflect.get(target, prop, receiver);
-      }
-
-      if (prop in target) {
-        return Reflect.get(target, prop, receiver);
-      }
-
-      const getItems = (target as { getItems?: () => unknown }).getItems;
-      if (typeof getItems === 'function') {
-        const items = getItems.call(target);
-        if (items && prop in (items as object)) {
-          const propName = prop as string;
-          const value = (items as Record<string, unknown>)[propName];
-          return typeof value === 'function' ? value.bind(items) : value;
-        }
-      }
-
-      const getRef = (target as { get?: () => unknown }).get;
-      if (typeof getRef === 'function') {
-        const current = getRef.call(target);
-        if (current && prop in (current as object)) {
-          const propName = prop as string;
-          const value = (current as Record<string, unknown>)[propName];
-          return typeof value === 'function' ? value.bind(current) : value;
-        }
-      }
-
-      return undefined;
-    },
-
-    set(target, prop, value, receiver) {
-      if (typeof prop === 'symbol') {
-        return Reflect.set(target, prop, value, receiver);
-      }
-
-      if (prop in target) {
-        return Reflect.set(target, prop, value, receiver);
-      }
-
-      const getRef = (target as { get?: () => unknown }).get;
-      if (typeof getRef === 'function') {
-        const current = getRef.call(target);
-        if (current && typeof current === 'object') {
-          return Reflect.set(current as object, prop, value);
-        }
-      }
-
-      const getItems = (target as { getItems?: () => unknown }).getItems;
-      if (typeof getItems === 'function') {
-        const items = getItems.call(target);
-        return Reflect.set(items as object, prop, value);
-      }
-
-      return Reflect.set(target, prop, value, receiver);
-    }
-  });
-};
-
-/**
- * Gets a relation wrapper for an entity.
- * @param meta - The entity metadata
- * @param relationName - The relation name
- * @param owner - The owner entity
- * @param createEntity - The entity factory for relation rows
- * @returns The relation wrapper or undefined
- */
-export const getRelationWrapper = <TTable extends TableDef>(
-  meta: EntityMeta<TTable>,
-  relationName: RelationKey<TTable> | string,
-  owner: unknown,
-  createEntity: RelationEntityFactory
-): HasManyCollection<unknown> | HasOneReference<object> | BelongsToReference<object> | ManyToManyCollection<unknown> | undefined => {
-  const relationKey = relationName as string;
-
-  if (meta.relationWrappers.has(relationKey)) {
-    return meta.relationWrappers.get(relationKey) as HasManyCollection<unknown>;
-  }
-
-  const relation = meta.table.relations[relationKey];
-  if (!relation) return undefined;
-
-  const wrapper = instantiateWrapper(meta, relationKey, relation, owner, createEntity);
-  if (!wrapper) return undefined;
-
-  const proxied = proxifyRelationWrapper(wrapper as object);
-  meta.relationWrappers.set(relationKey, proxied);
-  return proxied as HasManyCollection<unknown>;
-};
-
-/**
- * Instantiates the appropriate relation wrapper based on relation type.
- * @param meta - The entity metadata
- * @param relationName - The relation name
- * @param relation - The relation definition
- * @param owner - The owner entity
- * @param createEntity - The entity factory for relation rows
- * @returns The relation wrapper or undefined
- */
-const instantiateWrapper = <TTable extends TableDef>(
-  meta: EntityMeta<TTable>,
-  relationName: string,
-  relation: HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation,
-  owner: unknown,
-  createEntity: RelationEntityFactory
-): HasManyCollection<unknown> | HasOneReference<object> | BelongsToReference<object> | ManyToManyCollection<unknown> | undefined => {
-  const metaBase = meta as unknown as EntityMeta<TableDef>;
-  const loadCached = <T extends Map<string, unknown>>(factory: () => Promise<T>) =>
-    relationLoaderCache(metaBase, relationName, factory);
-  const resolveOptions = () => meta.lazyRelationOptions.get(relationName);
-  switch (relation.type) {
-    case RelationKinds.HasOne: {
-      const hasOne = relation as HasOneRelation;
-      const localKey = hasOne.localKey || findPrimaryKey(meta.table);
-      const loader = () => loadCached(() =>
-        loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne, resolveOptions())
-      );
-      return new DefaultHasOneReference(
-        meta.ctx,
-        metaBase,
-        owner,
-        relationName,
-        hasOne,
-        meta.table,
-        loader,
-        (row: Record<string, unknown>) => createEntity(hasOne.target, row),
-        localKey
-      );
-    }
-    case RelationKinds.HasMany: {
-      const hasMany = relation as HasManyRelation;
-      const localKey = hasMany.localKey || findPrimaryKey(meta.table);
-      const loader = () => loadCached(() =>
-        loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany, resolveOptions())
-      );
-      return new DefaultHasManyCollection(
-        meta.ctx,
-        metaBase,
-        owner,
-        relationName,
-        hasMany,
-        meta.table,
-        loader,
-        (row: Record<string, unknown>) => createEntity(relation.target, row),
-        localKey
-      );
-    }
-    case RelationKinds.BelongsTo: {
-      const belongsTo = relation as BelongsToRelation;
-      const targetKey = belongsTo.localKey || findPrimaryKey(belongsTo.target);
-      const loader = () => loadCached(() =>
-        loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo, resolveOptions())
-      );
-      return new DefaultBelongsToReference(
-        meta.ctx,
-        metaBase,
-        owner,
-        relationName,
-        belongsTo,
-        meta.table,
-        loader,
-        (row: Record<string, unknown>) => createEntity(relation.target, row),
-        targetKey
-      );
-    }
-    case RelationKinds.BelongsToMany: {
-      const many = relation as BelongsToManyRelation;
-      const localKey = many.localKey || findPrimaryKey(meta.table);
-      const loader = () => loadCached(() =>
-        loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many, resolveOptions())
-      );
-      return new DefaultManyToManyCollection(
-        meta.ctx,
-        metaBase,
-        owner,
-        relationName,
-        many,
-        meta.table,
-        loader,
-        (row: Record<string, unknown>) => createEntity(relation.target, row),
-        localKey
-      );
-    }
-    default:
-      return undefined;
-  }
-};
+import { TableDef } from '../schema/table.js';
+import { EntityInstance, HasManyCollection, HasOneReference, BelongsToReference, ManyToManyCollection } from '../schema/types.js';
+import { EntityMeta, RelationKey } from './entity-meta.js';
+import { DefaultHasManyCollection } from './relations/has-many.js';
+import { DefaultHasOneReference } from './relations/has-one.js';
+import { DefaultBelongsToReference } from './relations/belongs-to.js';
+import { DefaultManyToManyCollection } from './relations/many-to-many.js';
+import { DefaultMorphOneReference } from './relations/morph-one.js';
+import { DefaultMorphManyCollection } from './relations/morph-many.js';
+import { DefaultMorphToReference } from './relations/morph-to.js';
+import { HasManyRelation, HasOneRelation, BelongsToRelation, BelongsToManyRelation, MorphOneRelation, MorphManyRelation, MorphToRelation, RelationKinds } from '../schema/relation.js';
+import { loadHasManyRelation, loadHasOneRelation, loadBelongsToRelation, loadBelongsToManyRelation, loadMorphOneRelation, loadMorphManyRelation, loadMorphToRelation } from './lazy-batch.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import { relationLoaderCache } from './entity-relation-cache.js';
+
+export type RelationEntityFactory = (
+  table: TableDef,
+  row: Record<string, unknown>
+) => EntityInstance<TableDef>;
+
+const proxifyRelationWrapper = <T extends object>(wrapper: T): T => {
+  return new Proxy(wrapper, {
+    get(target, prop, receiver) {
+      if (typeof prop === 'symbol') {
+        return Reflect.get(target, prop, receiver);
+      }
+
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
+      }
+
+      const getItems = (target as { getItems?: () => unknown }).getItems;
+      if (typeof getItems === 'function') {
+        const items = getItems.call(target);
+        if (items && prop in (items as object)) {
+          const propName = prop as string;
+          const value = (items as Record<string, unknown>)[propName];
+          return typeof value === 'function' ? value.bind(items) : value;
+        }
+      }
+
+      const getRef = (target as { get?: () => unknown }).get;
+      if (typeof getRef === 'function') {
+        const current = getRef.call(target);
+        if (current && prop in (current as object)) {
+          const propName = prop as string;
+          const value = (current as Record<string, unknown>)[propName];
+          return typeof value === 'function' ? value.bind(current) : value;
+        }
+      }
+
+      return undefined;
+    },
+
+    set(target, prop, value, receiver) {
+      if (typeof prop === 'symbol') {
+        return Reflect.set(target, prop, value, receiver);
+      }
+
+      if (prop in target) {
+        return Reflect.set(target, prop, value, receiver);
+      }
+
+      const getRef = (target as { get?: () => unknown }).get;
+      if (typeof getRef === 'function') {
+        const current = getRef.call(target);
+        if (current && typeof current === 'object') {
+          return Reflect.set(current as object, prop, value);
+        }
+      }
+
+      const getItems = (target as { getItems?: () => unknown }).getItems;
+      if (typeof getItems === 'function') {
+        const items = getItems.call(target);
+        return Reflect.set(items as object, prop, value);
+      }
+
+      return Reflect.set(target, prop, value, receiver);
+    }
+  });
+};
+
+/**
+ * Gets a relation wrapper for an entity.
+ * @param meta - The entity metadata
+ * @param relationName - The relation name
+ * @param owner - The owner entity
+ * @param createEntity - The entity factory for relation rows
+ * @returns The relation wrapper or undefined
+ */
+export const getRelationWrapper = <TTable extends TableDef>(
+  meta: EntityMeta<TTable>,
+  relationName: RelationKey<TTable> | string,
+  owner: unknown,
+  createEntity: RelationEntityFactory
+): HasManyCollection<unknown> | HasOneReference<object> | BelongsToReference<object> | ManyToManyCollection<unknown> | undefined => {
+  const relationKey = relationName as string;
+
+  if (meta.relationWrappers.has(relationKey)) {
+    return meta.relationWrappers.get(relationKey) as HasManyCollection<unknown>;
+  }
+
+  const relation = meta.table.relations[relationKey];
+  if (!relation) return undefined;
+
+  const wrapper = instantiateWrapper(meta, relationKey, relation, owner, createEntity);
+  if (!wrapper) return undefined;
+
+  const proxied = proxifyRelationWrapper(wrapper as object);
+  meta.relationWrappers.set(relationKey, proxied);
+  return proxied as HasManyCollection<unknown>;
+};
+
+/**
+ * Instantiates the appropriate relation wrapper based on relation type.
+ * @param meta - The entity metadata
+ * @param relationName - The relation name
+ * @param relation - The relation definition
+ * @param owner - The owner entity
+ * @param createEntity - The entity factory for relation rows
+ * @returns The relation wrapper or undefined
+ */
+const instantiateWrapper = <TTable extends TableDef>(
+  meta: EntityMeta<TTable>,
+  relationName: string,
+  relation: HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation | MorphOneRelation | MorphManyRelation | MorphToRelation,
+  owner: unknown,
+  createEntity: RelationEntityFactory
+): HasManyCollection<unknown> | HasOneReference<object> | BelongsToReference<object> | ManyToManyCollection<unknown> | undefined => {
+  const metaBase = meta as unknown as EntityMeta<TableDef>;
+  const loadCached = <T extends Map<string, unknown>>(factory: () => Promise<T>) =>
+    relationLoaderCache(metaBase, relationName, factory);
+  const resolveOptions = () => meta.lazyRelationOptions.get(relationName);
+  switch (relation.type) {
+    case RelationKinds.HasOne: {
+      const hasOne = relation as HasOneRelation;
+      const localKey = hasOne.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(() =>
+        loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne, resolveOptions())
+      );
+      return new DefaultHasOneReference(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        hasOne,
+        meta.table,
+        loader,
+        (row: Record<string, unknown>) => createEntity(hasOne.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.HasMany: {
+      const hasMany = relation as HasManyRelation;
+      const localKey = hasMany.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(() =>
+        loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany, resolveOptions())
+      );
+      return new DefaultHasManyCollection(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        hasMany,
+        meta.table,
+        loader,
+        (row: Record<string, unknown>) => createEntity(relation.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.BelongsTo: {
+      const belongsTo = relation as BelongsToRelation;
+      const targetKey = belongsTo.localKey || findPrimaryKey(belongsTo.target);
+      const loader = () => loadCached(() =>
+        loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo, resolveOptions())
+      );
+      return new DefaultBelongsToReference(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        belongsTo,
+        meta.table,
+        loader,
+        (row: Record<string, unknown>) => createEntity(relation.target, row),
+        targetKey
+      );
+    }
+    case RelationKinds.BelongsToMany: {
+      const many = relation as BelongsToManyRelation;
+      const localKey = many.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(() =>
+        loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many, resolveOptions())
+      );
+      return new DefaultManyToManyCollection(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        many,
+        meta.table,
+        loader,
+        (row: Record<string, unknown>) => createEntity(relation.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.MorphOne: {
+      const morphOne = relation as MorphOneRelation;
+      const localKey = morphOne.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(() =>
+        loadMorphOneRelation(meta.ctx, meta.table, relationName, morphOne, resolveOptions())
+      );
+      return new DefaultMorphOneReference(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        morphOne,
+        meta.table,
+        loader,
+        (row: Record<string, unknown>) => createEntity(morphOne.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.MorphMany: {
+      const morphMany = relation as MorphManyRelation;
+      const localKey = morphMany.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(() =>
+        loadMorphManyRelation(meta.ctx, meta.table, relationName, morphMany, resolveOptions())
+      );
+      return new DefaultMorphManyCollection(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        morphMany,
+        meta.table,
+        loader,
+        (row: Record<string, unknown>) => createEntity(morphMany.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.MorphTo: {
+      const morphTo = relation as MorphToRelation;
+      const loader = () => loadCached(() =>
+        loadMorphToRelation(meta.ctx, meta.table, relationName, morphTo)
+      );
+      const resolveTargetTable = (typeValue: string) => morphTo.targets[typeValue];
+      return new DefaultMorphToReference(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        morphTo,
+        meta.table,
+        loader,
+        (table: TableDef, row: Record<string, unknown>) => createEntity(table, row),
+        resolveTargetTable
+      );
+    }
+    default:
+      return undefined;
+  }
+};