metal-orm 1.0.70 → 1.0.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.70",
+  "version": "1.0.72",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {
@@ -23,6 +23,7 @@
     "scripts"
   ],
   "scripts": {
+    "prepublishOnly": "npm run build",
     "build": "tsup",
     "check": "tsc --noEmit",
     "gen:entities": "node scripts/generate-entities.mjs",

package/src/orm/entity.ts

@@ -7,13 +7,20 @@ 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
+export { relationLoaderCache } from './entity-relation-cache.js';
+
+const isRelationWrapperLoaded = (value: unknown): boolean => {
+  if (!value || typeof value !== 'object') return false;
+  return Boolean((value as { loaded?: boolean }).loaded);
+};
+
+type JsonSource<TTable extends TableDef> = EntityInstance<TTable> & Record<string, unknown>;
+
+/**
+ * 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
@@ -28,26 +35,39 @@ export const createEntityProxy = <
   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,
+): 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
-  });
+    relationHydration: new Map(),
+    relationWrappers: new Map()
+  };
+  const createRelationEntity: RelationEntityFactory = (relationTable, relationRow) =>
+    createEntityFromRow(meta.ctx, relationTable, relationRow);
+
+  const buildJson = (self: JsonSource<TTable>): Record<string, unknown> => {
+    const json: Record<string, unknown> = {};
+    for (const key of Object.keys(target)) {
+      json[key] = self[key];
+    }
+    for (const [relationName, wrapper] of meta.relationWrappers) {
+      if (Object.prototype.hasOwnProperty.call(json, relationName)) continue;
+      if (isRelationWrapperLoaded(wrapper)) {
+        json[relationName] = wrapper;
+      }
+    }
+    return json;
+  };
+
+  Object.defineProperty(target, ENTITY_META, {
+    value: meta,
+    enumerable: false,
+    writable: false
+  });
 
   const handler: ProxyHandler<object> = {
     get(targetObj, prop, receiver) {
@@ -55,21 +75,28 @@ export const createEntityProxy = <
         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);
+      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 (prop === 'toJSON') {
+        if (prop in targetObj) {
+          return Reflect.get(targetObj, prop, receiver);
+        }
+        return () => buildJson(receiver as JsonSource<TTable>);
+      }
+
+      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) {
@@ -77,14 +104,14 @@ export const createEntityProxy = <
       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;
-};
+      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.