linkgress-orm 0.4.66 → 0.4.68

package/dist/query/query-builder.js

@@ -16,6 +16,7 @@ const collection_strategy_factory_1 = require("./collection-strategy.factory");
 const union_builder_1 = require("./union-builder");
 const future_query_1 = require("./future-query");
 const mock_row_cache_1 = require("./mock-row-cache");
+const navigation_path_cache_1 = require("./navigation-path-cache");
 const join_utils_1 = require("./join-utils");
 /**
  * Field type categories for optimized result transformation
@@ -79,6 +80,39 @@ const MOCK_ROW_NAV_CACHE = Symbol('linkgressMockNavCache');
 const navigationPathSignature = (path) => path
     .map(step => `${step.alias}:${step.targetTable}:${(step.foreignKeys ?? []).join('+')}:${(step.matches ?? []).join('+')}:${step.isMandatory ? 1 : 0}:${step.sourceAlias ?? ''}`)
     .join('>');
+/**
+ * Whether `value` is a reference mock row minted by `ReferenceQueryBuilder.createMockTargetRow`.
+ * Those rows INHERIT their column/relation getters from a shared prototype (see MockRowCache),
+ * so `Object.getPrototypeOf(row) !== Object.prototype` and own-property APIs see no columns —
+ * the row's own state slots are the reliable marker.
+ */
+const isReferenceMockRow = (value) => value != null && typeof value === 'object' && Object.prototype.hasOwnProperty.call(value, MOCK_ROW_FIELD_REFS);
+/** `Object.getOwnPropertyDescriptor` that walks the prototype chain (stops before Object.prototype). */
+const findPropertyDescriptor = (value, key) => {
+    let current = value;
+    while (current != null && current !== Object.prototype) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, key);
+        if (descriptor) {
+            return descriptor;
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return undefined;
+};
+/**
+ * First enumerable key (own or inherited) backed by a getter — the "is this a mock row" probe
+ * shared by the selection resolvers. Root mocks define their getters as own properties,
+ * reference mocks inherit them; column getters are enumerable on both, so the first
+ * enumerable getter is always a column and `row[key]` yields its FieldRef.
+ */
+const findFirstGetterKey = (value) => {
+    for (const key in value) {
+        if (findPropertyDescriptor(value, key)?.get != null) {
+            return key;
+        }
+    }
+    return undefined;
+};
 /**
  * Performance utility: Get target schema for a relation, using cached version if available
  */
@@ -1702,7 +1736,10 @@ class SelectQueryBuilder {
             // tryBuildFlatNestedSelect flattens. Class instances (collections, SqlFragment,
             // Subquery) and collection-result markers must not be walked.
             const proto = Object.getPrototypeOf(value);
-            if ((proto === Object.prototype || proto === null) && !('__collectionResult' in value)) {
+            // Reference mock rows inherit their getters from a shared prototype (see
+            // createMockTargetRow) yet must keep being walked exactly like the plain-object mocks
+            // they replaced.
+            if ((proto === Object.prototype || proto === null || isReferenceMockRow(value)) && !('__collectionResult' in value)) {
                 this.collectJsonRowRevivals(value, pathPrefix ? `${pathPrefix}__${key}` : `__nested__${key}`, revivals, textColumns);
             }
         }
@@ -4097,19 +4134,15 @@ ${joinClauses.join('\n')}`;
                                 continue;
                             }
                         }
-                        // Check if it's a mock object with property descriptors (navigation property mock)
-                        const props = Object.getOwnPropertyNames(value);
-                        if (props.length > 0) {
-                            const firstProp = props[0];
-                            const descriptor = Object.getOwnPropertyDescriptor(value, firstProp);
-                            if (descriptor && descriptor.get) {
+                        // Check if it's a mock object with getter-backed properties (navigation property
+                        // mock). The getters may be OWN (root mocks) or INHERITED from the shared
+                        // prototype (reference mocks) — findFirstGetterKey walks both.
+                        {
+                            const tableAlias = findFirstGetterKey(value);
+                            if (tableAlias) {
                                 // This object has getter properties - likely a navigation mock
                                 // Try to determine if this is a reference navigation by checking the schema relations
-                                const tableAlias = Object.keys(value).find(k => {
-                                    const desc = Object.getOwnPropertyDescriptor(value, k);
-                                    return desc && desc.get && typeof desc.get === 'function';
-                                });
-                                if (tableAlias) {
+                                {
                                     // Try to get the first property to check if it has __tableAlias
                                     try {
                                         const firstValue = value[tableAlias];
@@ -4761,15 +4794,12 @@ ${joinClauses.join('\n')}`;
             // These are treated as SIMPLE because the actual value comes from json_build_object in the row
             // The navigation mock is just a placeholder - actual data processing happens via FieldType.SIMPLE
             if (value && typeof value === 'object' && !('__dbColumnName' in value) && !('__fieldName' in value) && !('__collectionResult' in value) && !('__isAggregationArray' in value)) {
-                const props = Object.getOwnPropertyNames(value);
-                if (props.length > 0) {
-                    const descriptor = Object.getOwnPropertyDescriptor(value, props[0]);
-                    if (descriptor && descriptor.get) {
-                        // Navigation mock - treat as simple, data will come from row via json_build_object
-                        // If row has no data, convertValue will return undefined
-                        fieldConfigs.push({ key, type: 8 /* FieldType.SIMPLE */, value });
-                        continue;
-                    }
+                // Getter-backed row (own getters on a root mock, inherited ones on a reference mock).
+                if (findFirstGetterKey(value) != null) {
+                    // Navigation mock - treat as simple, data will come from row via json_build_object
+                    // If row has no data, convertValue will return undefined
+                    fieldConfigs.push({ key, type: 8 /* FieldType.SIMPLE */, value });
+                    continue;
                 }
             }
             // Collection types
@@ -5598,20 +5628,24 @@ class ReferenceQueryBuilder {
      */
     createMockTargetRow() {
         if (this.targetTableSchema) {
-            // Descriptor-level cache — see MockRowCache's doc. Everything the descriptors close
-            // over is fully determined by (target schema object identity, relationName,
-            // sourceAlias, navigation-path content), so rows with the same signature can share
-            // one prebuilt PropertyDescriptorMap. The cross-row cache is OPT-IN via the static
-            // switch (MockRowCache.setEnabled — the host app flips it from its own config):
-            // with it off, each row gets a FRESH descriptor set (the pre-0.4.66 memory profile
-            // — nothing retained beyond the row's lifetime), while the per-row FieldRef and
-            // navigation slots below stay enabled either way (they are row-scoped).
-            const descriptors = mock_row_cache_1.MockRowCache.getOrBuild(`${this.targetTable}|${this.relationName}|${this.sourceAlias ?? ''}|${navigationPathSignature(this.navigationPath)}`, () => this.buildMockRowDescriptors());
-            const mock = {
-                [MOCK_ROW_FIELD_REFS]: {},
-                [MOCK_ROW_NAV_CACHE]: {},
-            };
-            Object.defineProperties(mock, descriptors);
+            // Prototype-level cache — see MockRowCache's doc. Everything the getters close over
+            // is fully determined by (target schema object identity, relationName, sourceAlias,
+            // navigation-path content), so rows with the same signature can share one prebuilt
+            // PROTOTYPE carrying every column/relation getter; a new row is then `Object.create`
+            // plus its two own state slots — O(1) instead of one property definition per column.
+            // The cross-row cache is OPT-IN via the static switch (MockRowCache.setEnabled — the
+            // host app flips it from its own config): with it off, each row gets a FRESH
+            // prototype (the pre-0.4.66 memory profile — nothing retained beyond the row's
+            // lifetime), while the per-row FieldRef and navigation slots stay row-scoped either
+            // way (the shared getters read them through `this`).
+            //
+            // Consumers must not probe these rows with OWN-property APIs (`Object.keys`,
+            // `getOwnPropertyNames`, `getOwnPropertyDescriptor` on the row itself) — the getters
+            // are inherited. Use `isReferenceMockRow` / `findFirstGetterKey` instead.
+            const prototype = mock_row_cache_1.MockRowCache.getOrBuild(`${this.targetTable}|${this.relationName}|${this.sourceAlias ?? ''}|${navigationPathSignature(this.navigationPath)}`, () => Object.defineProperties({}, this.buildMockRowDescriptors()));
+            const mock = Object.create(prototype);
+            mock[MOCK_ROW_FIELD_REFS] = {};
+            mock[MOCK_ROW_NAV_CACHE] = {};
             return mock;
         }
         else {
@@ -6491,6 +6525,19 @@ class CollectionQueryBuilder {
      * Uses BFS to find the shortest path through the schema graph
      */
     findNavigationPath(targetAlias, joinedSchemas, _startSchema) {
+        if (!this.schemaRegistry) {
+            return [];
+        }
+        // Memoised per registry — the BFS below depends only on the target alias and the ORDERED
+        // joined alias→table pairs (order decides which of several equal-length paths wins), so
+        // the same query shape resolves to the same path on every build. See NavigationPathCache.
+        const signature = `${targetAlias}|${[...joinedSchemas]
+            .map(([alias, schema]) => `${alias}:${schema.schema ?? ''}.${schema.name}`)
+            .join(',')}`;
+        return navigation_path_cache_1.NavigationPathCache.getOrBuild(this.schemaRegistry, signature, () => this.computeNavigationPath(targetAlias, joinedSchemas));
+    }
+    /** The uncached BFS behind {@link findNavigationPath}. */
+    computeNavigationPath(targetAlias, joinedSchemas) {
         if (!this.schemaRegistry) {
             return [];
         }