metal-orm 1.0.57 → 1.0.59

package/src/orm/entity-relations.ts

@@ -0,0 +1,207 @@
+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 lazyOptions = meta.lazyRelationOptions.get(relationName);
+  const loadCached = <T extends Map<string, unknown>>(factory: () => Promise<T>) =>
+    relationLoaderCache(metaBase, relationName, factory);
+  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, lazyOptions)
+      );
+      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, lazyOptions)
+      );
+      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, lazyOptions)
+      );
+      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, lazyOptions)
+      );
+      return new DefaultManyToManyCollection(
+        meta.ctx,
+        metaBase,
+        owner,
+        relationName,
+        many,
+        meta.table,
+        loader,
+        (row: Record<string, unknown>) => createEntity(relation.target, row),
+        localKey
+      );
+    }
+    default:
+      return undefined;
+  }
+};

package/src/orm/entity.ts

@@ -1,343 +1,124 @@
-import { TableDef } from '../schema/table.js';
-import { EntityInstance, RelationMap, HasManyCollection, HasOneReference, BelongsToReference, ManyToManyCollection } from '../schema/types.js';
-import { EntityContext } from './entity-context.js';
-import { ENTITY_META, EntityMeta, getEntityMeta } 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';
-
-/**
- * Type representing an array of database rows.
- */
-type Rows = Record<string, unknown>[];
-
-/**
- * Caches relation loader results across entities of the same type.
- * @template T - The cache type
- * @param meta - The entity metadata
- * @param relationName - The relation name
- * @param factory - The factory function to create the cache
- * @returns Promise with the cached relation data
- */
-const relationLoaderCache = <T extends Map<string, unknown>>(
-  meta: EntityMeta<TableDef>,
-  relationName: string,
-  factory: () => Promise<T>
-): Promise<T> => {
-  if (meta.relationCache.has(relationName)) {
-    return meta.relationCache.get(relationName)! as Promise<T>;
-  }
-
-  const promise = factory().then(value => {
-    for (const tracked of meta.ctx.getEntitiesForTable(meta.table)) {
-      const otherMeta = getEntityMeta(tracked.entity);
-      if (!otherMeta) continue;
-      otherMeta.relationHydration.set(relationName, value);
-    }
-    return value;
-  });
-
-  meta.relationCache.set(relationName, promise);
-
-  for (const tracked of meta.ctx.getEntitiesForTable(meta.table)) {
-    const otherMeta = getEntityMeta(tracked.entity);
-    if (!otherMeta) continue;
-    otherMeta.relationCache.set(relationName, promise);
-  }
-
-  return promise;
-};
-
-/**
- * Creates an entity proxy with lazy loading capabilities.
- * @template TTable - The table type
- * @template TLazy - The lazy relation keys
- * @param ctx - The entity context
- * @param table - The table definition
- * @param row - The database row
- * @param lazyRelations - Optional lazy relations
- * @returns The entity instance
- */
-export const createEntityProxy = <
-  TTable extends TableDef,
-  TLazy extends keyof RelationMap<TTable> = keyof RelationMap<TTable>
->(
-  ctx: EntityContext,
-  table: TTable,
-  row: Record<string, unknown>,
-  lazyRelations: TLazy[] = [] as TLazy[]
-): EntityInstance<TTable> => {
-  const target: Record<string, unknown> = { ...row };
-  const meta: EntityMeta<TTable> = {
-    ctx,
-    table,
-    lazyRelations: [...lazyRelations],
-    relationCache: new Map(),
-    relationHydration: new Map(),
-    relationWrappers: new Map()
-  };
-
-  Object.defineProperty(target, ENTITY_META, {
-    value: meta,
-    enumerable: false,
-    writable: false
-  });
-
-  const handler: ProxyHandler<object> = {
-    get(targetObj, prop, receiver) {
-      if (prop === ENTITY_META) {
-        return meta;
-      }
-
-      if (prop === '$load') {
-        return async (relationName: keyof RelationMap<TTable>) => {
-          const wrapper = getRelationWrapper(meta as unknown as EntityMeta<TableDef>, relationName as string, receiver);
-          if (wrapper && typeof wrapper.load === 'function') {
-            return wrapper.load();
-          }
-          return undefined;
-        };
-      }
-
-      if (typeof prop === 'string' && table.relations[prop]) {
-        return getRelationWrapper(meta as unknown as EntityMeta<TableDef>, 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(receiver);
-      }
-      return result;
-    }
-  };
-
-  const proxy = new Proxy(target, handler) as EntityInstance<TTable>;
-  populateHydrationCache(proxy, row, meta);
-  return proxy;
-};
-
-/**
- * Creates an entity instance from a database row.
- * @template TTable - The table type
- * @template TResult - The result type
- * @param ctx - The entity context
- * @param table - The table definition
- * @param row - The database row
- * @param lazyRelations - Optional lazy relations
- * @returns The entity instance
- */
-export const createEntityFromRow = <
-  TTable extends TableDef,
-  TResult extends EntityInstance<TTable> = EntityInstance<TTable>
->(
-  ctx: EntityContext,
-  table: TTable,
-  row: Record<string, unknown>,
-  lazyRelations: (keyof RelationMap<TTable>)[] = []
-): TResult => {
-  const pkName = findPrimaryKey(table);
-  const pkValue = row[pkName];
-  if (pkValue !== undefined && pkValue !== null) {
-    const tracked = ctx.getEntity(table, pkValue);
-    if (tracked) return tracked as TResult;
-  }
-
-  const entity = createEntityProxy(ctx, table, row, lazyRelations);
-  if (pkValue !== undefined && pkValue !== null) {
-    ctx.trackManaged(table, pkValue, entity);
-  } else {
-    ctx.trackNew(table, entity);
-  }
-
-  return entity as TResult;
-};
-
-/**
- * Converts a value to a string key.
- * @param value - The value to convert
- * @returns String representation of the value
- */
-const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-/**
- * Populates the hydration cache with relation data from the database row.
- * @template TTable - The table type
- * @param entity - The entity instance
- * @param row - The database row
- * @param meta - The entity metadata
- */
-const populateHydrationCache = <TTable extends TableDef>(
-  entity: Record<string, unknown>,
-  row: Record<string, unknown>,
-  meta: EntityMeta<TTable>
-): void => {
-  for (const relationName of Object.keys(meta.table.relations)) {
-    const relation = meta.table.relations[relationName];
-    const data = row[relationName];
-    if (relation.type === RelationKinds.HasOne) {
-      const localKey = relation.localKey || findPrimaryKey(meta.table);
-      const rootValue = entity[localKey];
-      if (rootValue === undefined || rootValue === null) continue;
-      if (!data || typeof data !== 'object') continue;
-      const cache = new Map<string, Record<string, unknown>>();
-      cache.set(toKey(rootValue), data as Record<string, unknown>);
-      meta.relationHydration.set(relationName, cache);
-      meta.relationCache.set(relationName, Promise.resolve(cache));
-      continue;
-    }
-
-    if (!Array.isArray(data)) continue;
-
-    if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-      const localKey = relation.localKey || findPrimaryKey(meta.table);
-      const rootValue = entity[localKey];
-      if (rootValue === undefined || rootValue === null) continue;
-      const cache = new Map<string, Rows>();
-      cache.set(toKey(rootValue), data as Rows);
-      meta.relationHydration.set(relationName, cache);
-      meta.relationCache.set(relationName, Promise.resolve(cache));
-      continue;
-    }
-
-    if (relation.type === RelationKinds.BelongsTo) {
-      const targetKey = relation.localKey || findPrimaryKey(relation.target);
-      const cache = new Map<string, Record<string, unknown>>();
-      for (const item of data) {
-        const pkValue = item[targetKey];
-        if (pkValue === undefined || pkValue === null) continue;
-        cache.set(toKey(pkValue), item);
-      }
-      if (cache.size) {
-        meta.relationHydration.set(relationName, cache);
-        meta.relationCache.set(relationName, Promise.resolve(cache));
-      }
-    }
-  }
-};
-
-/**
- * Gets a relation wrapper for an entity.
- * @param meta - The entity metadata
- * @param relationName - The relation name
- * @param owner - The owner entity
- * @returns The relation wrapper or undefined
- */
-const getRelationWrapper = (
-  meta: EntityMeta<TableDef>,
-  relationName: string,
-  owner: unknown
-): HasManyCollection<unknown> | HasOneReference<unknown> | BelongsToReference<unknown> | ManyToManyCollection<unknown> | undefined => {
-  if (meta.relationWrappers.has(relationName)) {
-    return meta.relationWrappers.get(relationName) as HasManyCollection<unknown>;
-  }
-
-  const relation = meta.table.relations[relationName];
-  if (!relation) return undefined;
-
-  const wrapper = instantiateWrapper(meta, relationName, relation, owner);
-  if (wrapper) {
-    meta.relationWrappers.set(relationName, wrapper);
-  }
-
-  return wrapper;
-};
-
-/**
- * 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
- * @returns The relation wrapper or undefined
- */
-const instantiateWrapper = (
-  meta: EntityMeta<TableDef>,
-  relationName: string,
-  relation: HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation,
-  owner: unknown
-): HasManyCollection<unknown> | HasOneReference<unknown> | BelongsToReference<unknown> | ManyToManyCollection<unknown> | undefined => {
-  switch (relation.type) {
-    case RelationKinds.HasOne: {
-      const hasOne = relation as HasOneRelation;
-      const localKey = hasOne.localKey || findPrimaryKey(meta.table);
-      const loader = () => relationLoaderCache(meta, relationName, () =>
-        loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne)
-      );
-      return new DefaultHasOneReference(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        hasOne,
-        meta.table,
-        loader,
-        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, hasOne.target, row),
-        localKey
-      );
-    }
-    case RelationKinds.HasMany: {
-      const hasMany = relation as HasManyRelation;
-      const localKey = hasMany.localKey || findPrimaryKey(meta.table);
-      const loader = () => relationLoaderCache(meta, relationName, () =>
-        loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany)
-      );
-      return new DefaultHasManyCollection(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        hasMany,
-        meta.table,
-        loader,
-        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
-        localKey
-      );
-    }
-    case RelationKinds.BelongsTo: {
-      const belongsTo = relation as BelongsToRelation;
-      const targetKey = belongsTo.localKey || findPrimaryKey(belongsTo.target);
-      const loader = () => relationLoaderCache(meta, relationName, () =>
-        loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo)
-      );
-      return new DefaultBelongsToReference(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        belongsTo,
-        meta.table,
-        loader,
-        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
-        targetKey
-      );
-    }
-    case RelationKinds.BelongsToMany: {
-      const many = relation as BelongsToManyRelation;
-      const localKey = many.localKey || findPrimaryKey(meta.table);
-      const loader = () => relationLoaderCache(meta, relationName, () =>
-        loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many)
-      );
-      return new DefaultManyToManyCollection(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        many,
-        meta.table,
-        loader,
-        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
-        localKey
-      );
-    }
-    default:
-      return undefined;
-  }
-};
+import { TableDef } from '../schema/table.js';
+import { EntityInstance } from '../schema/types.js';
+import { EntityContext } from './entity-context.js';
+import { ENTITY_META, EntityMeta, RelationKey } from './entity-meta.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import { RelationIncludeOptions } from '../query-builder/relation-types.js';
+import { populateHydrationCache } from './entity-hydration.js';
+import { getRelationWrapper, RelationEntityFactory } from './entity-relations.js';
+
+export { relationLoaderCache } from './entity-relation-cache.js';
+
+/**
+ * Creates an entity proxy with lazy loading capabilities.
+ * @template TTable - The table type
+ * @template TLazy - The lazy relation keys
+ * @param ctx - The entity context
+ * @param table - The table definition
+ * @param row - The database row
+ * @param lazyRelations - Optional lazy relations
+ * @returns The entity instance
+ */
+export const createEntityProxy = <
+  TTable extends TableDef,
+  TLazy extends RelationKey<TTable> = RelationKey<TTable>
+>(
+  ctx: EntityContext,
+  table: TTable,
+  row: Record<string, unknown>,
+  lazyRelations: TLazy[] = [] as TLazy[],
+  lazyRelationOptions: Map<string, RelationIncludeOptions> = new Map()
+): EntityInstance<TTable> => {
+  const target: Record<string, unknown> = { ...row };
+  const meta: EntityMeta<TTable> = {
+    ctx,
+    table,
+    lazyRelations: [...lazyRelations],
+    lazyRelationOptions: new Map(lazyRelationOptions),
+    relationCache: new Map(),
+    relationHydration: new Map(),
+    relationWrappers: new Map()
+  };
+
+  const createRelationEntity: RelationEntityFactory = (relationTable, relationRow) =>
+    createEntityFromRow(meta.ctx, relationTable, relationRow);
+
+  Object.defineProperty(target, ENTITY_META, {
+    value: meta,
+    enumerable: false,
+    writable: false
+  });
+
+  const handler: ProxyHandler<object> = {
+    get(targetObj, prop, receiver) {
+      if (prop === ENTITY_META) {
+        return meta;
+      }
+
+      if (prop === '$load') {
+        return async (relationName: RelationKey<TTable>) => {
+          const wrapper = getRelationWrapper(meta, relationName, receiver, createRelationEntity);
+          if (wrapper && typeof wrapper.load === 'function') {
+            return wrapper.load();
+          }
+          return undefined;
+        };
+      }
+
+      if (typeof prop === 'string' && table.relations[prop]) {
+        return getRelationWrapper(meta, prop as RelationKey<TTable>, receiver, createRelationEntity);
+      }
+
+      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(receiver);
+      }
+      return result;
+    }
+  };
+
+  const proxy = new Proxy(target, handler) as EntityInstance<TTable>;
+  populateHydrationCache(proxy, row, meta);
+  return proxy;
+};
+
+/**
+ * Creates an entity instance from a database row.
+ * @template TTable - The table type
+ * @template TResult - The result type
+ * @param ctx - The entity context
+ * @param table - The table definition
+ * @param row - The database row
+ * @param lazyRelations - Optional lazy relations
+ * @returns The entity instance
+ */
+export const createEntityFromRow = <
+  TTable extends TableDef,
+  TResult extends EntityInstance<TTable> = EntityInstance<TTable>
+>(
+  ctx: EntityContext,
+  table: TTable,
+  row: Record<string, unknown>,
+  lazyRelations: RelationKey<TTable>[] = [],
+  lazyRelationOptions: Map<string, RelationIncludeOptions> = new Map()
+): TResult => {
+  const pkName = findPrimaryKey(table);
+  const pkValue = row[pkName];
+  if (pkValue !== undefined && pkValue !== null) {
+    const tracked = ctx.getEntity(table, pkValue);
+    if (tracked) return tracked as TResult;
+  }
+
+  const entity = createEntityProxy(ctx, table, row, lazyRelations, lazyRelationOptions);
+  if (pkValue !== undefined && pkValue !== null) {
+    ctx.trackManaged(table, pkValue, entity);
+  } else {
+    ctx.trackNew(table, entity);
+  }
+
+  return entity as TResult;
+};