linkgress-orm 0.4.65 → 0.4.67

package/dist/query/query-builder.js

@@ -15,6 +15,7 @@ const cte_builder_1 = require("./cte-builder");
 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 join_utils_1 = require("./join-utils");
 /**
  * Field type categories for optimized result transformation
@@ -57,6 +58,60 @@ function getRelationEntriesForSchema(schema) {
     // Fallback: build the array (for schemas that weren't built with the new TableBuilder)
     return Object.entries(schema.relations);
 }
+/**
+ * Mock-row descriptor cache for {@link ReferenceQueryBuilder.createMockTargetRow}.
+ *
+ * Building a reference mock row costs O(columns + relations) `Object.defineProperty`
+ * calls plus fresh closures per row — and deep selectors (cart → items → product →
+ * price → …) rebuild that graph from scratch on EVERY query build. All of it is
+ * deterministic in (target schema, relation alias, navigation path), so the property
+ * descriptors are built once per signature and reused: each new mock row is a bare
+ * object + one `Object.defineProperties` call with the shared descriptor map.
+ *
+ * Per-instance state (the lazy FieldRef cache and the memoized navigation rows)
+ * lives in symbol-keyed slots read by the shared getters through `this`, so sharing
+ * descriptors across rows is safe. The navigation-path arrays captured at build
+ * time are shared by content — nothing downstream mutates them (they are always
+ * spread-copied when extended).
+ */
+const MOCK_ROW_FIELD_REFS = Symbol('linkgressMockFieldRefs');
+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
  */
@@ -1680,7 +1735,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);
             }
         }
@@ -3172,11 +3230,11 @@ class SelectQueryBuilder {
             joinClauses.push(collection.joinClause);
         }
         // Build the final CTE query
-        const sql = `WITH "__mutation__" AS (
-  ${mutationWithReturning}
-)
-SELECT ${selectParts.join(', ')}
-FROM "__mutation__"
+        const sql = `WITH "__mutation__" AS (
+  ${mutationWithReturning}
+)
+SELECT ${selectParts.join(', ')}
+FROM "__mutation__"
 ${joinClauses.join('\n')}`;
         return { sql, params: allParams, nestedPaths };
     }
@@ -4075,19 +4133,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];
@@ -4739,15 +4793,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
@@ -5576,120 +5627,166 @@ class ReferenceQueryBuilder {
      */
     createMockTargetRow() {
         if (this.targetTableSchema) {
-            const mock = {};
-            // Add columns - use pre-computed column name map if available
-            const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
-            // Performance: Lazy-cache FieldRef objects
-            const fieldRefCache = {};
-            const tableAlias = this.relationName;
-            // Build a mapper lookup for columns (only when needed)
-            const columnMappers = {};
-            const columnSqlTypes = {};
-            for (const [colName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
-                const config = colBuilder.build();
-                if (config.mapper) {
-                    columnMappers[colName] = config.mapper;
-                }
-                if (config.type) {
-                    columnSqlTypes[colName] = config.type;
-                }
-            }
-            const sourceTable = this.targetTable; // Actual table name for schema lookup
-            // Collect all navigation aliases from the path leading to this reference
-            // This is needed for WHERE conditions that use multi-level navigation (e.g., task.level.name)
-            const navigationAliases = this.navigationPath.map(nav => nav.alias);
-            for (const [colName, dbColumnName] of columnNameMap) {
-                const mapper = columnMappers[colName];
-                Object.defineProperty(mock, colName, {
-                    get() {
-                        let cached = fieldRefCache[colName];
-                        if (!cached) {
-                            cached = fieldRefCache[colName] = {
-                                __fieldName: colName,
-                                __dbColumnName: dbColumnName,
-                                __tableAlias: tableAlias, // Alias for SQL generation
-                                __sourceTable: sourceTable, // Actual table name for mapper lookup
-                                __mapper: mapper, // Include mapper for toDriver transformation in conditions
-                                __sqlType: columnSqlTypes[colName], // Column SQL type — lets flag* emit width-exact mask casts
-                                __navigationAliases: navigationAliases, // All intermediate navigation aliases for JOIN resolution
-                            };
-                        }
-                        return cached;
-                    },
-                    enumerable: true,
-                    configurable: true,
-                });
+            // 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 {
+            // Fallback: use the shared nested proxy that supports deep property access
+            return createNestedFieldRefProxy(this.relationName);
+        }
+    }
+    /**
+     * Builds the shared property-descriptor map for {@link createMockTargetRow}'s cached path.
+     * The getters read per-row state through `this`-bound symbol slots, so one descriptor
+     * map serves every row of the same signature.
+     */
+    buildMockRowDescriptors() {
+        // Add columns - use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
+        const tableAlias = this.relationName;
+        // Build a mapper lookup for columns (only when needed)
+        const columnMappers = {};
+        const columnSqlTypes = {};
+        for (const [colName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
+            const config = colBuilder.build();
+            if (config.mapper) {
+                columnMappers[colName] = config.mapper;
             }
-            // Build extended navigation path for nested collections
-            // Only build navigation path if we have a sourceAlias (meaning we're inside a collection's selector)
-            // If sourceAlias is empty, we're in the main query and references are joined in the FROM clause
-            let extendedNavPath = [];
-            if (this.sourceAlias) {
-                // Build the current navigation step to include in path for nested collections
-                // This represents the join from sourceAlias to this.relationName (this.targetTable)
-                const currentNavStep = {
-                    alias: this.relationName,
-                    targetTable: this.targetTable,
-                    foreignKeys: this.foreignKeys,
-                    matches: this.matches.length > 0 ? this.matches : ['id'], // Default to 'id' if not specified
-                    isMandatory: this.isMandatory,
-                    sourceAlias: this.sourceAlias,
-                };
-                extendedNavPath = [...this.navigationPath, currentNavStep];
+            if (config.type) {
+                columnSqlTypes[colName] = config.type;
             }
-            // Add navigation properties (both collections and references)
-            if (this.targetTableSchema.relations) {
-                for (const [relName, relConfig] of Object.entries(this.targetTableSchema.relations)) {
-                    // Try to get target schema from registry (preferred, has full relations) or targetTableBuilder
-                    let nestedTargetSchema;
-                    if (this.schemaRegistry) {
-                        nestedTargetSchema = this.schemaRegistry.get(relConfig.targetTable);
-                    }
-                    if (!nestedTargetSchema && relConfig.targetTableBuilder) {
-                        nestedTargetSchema = relConfig.targetTableBuilder.build();
+        }
+        const sourceTable = this.targetTable; // Actual table name for schema lookup
+        // Collect all navigation aliases from the path leading to this reference
+        // This is needed for WHERE conditions that use multi-level navigation (e.g., task.level.name)
+        const navigationAliases = this.navigationPath.map(nav => nav.alias);
+        const descriptors = {};
+        for (const [colName, dbColumnName] of columnNameMap) {
+            const mapper = columnMappers[colName];
+            descriptors[colName] = {
+                get() {
+                    const slots = this;
+                    const fieldRefCache = slots[MOCK_ROW_FIELD_REFS] ?? (slots[MOCK_ROW_FIELD_REFS] = {});
+                    let cached = fieldRefCache[colName];
+                    if (!cached) {
+                        cached = fieldRefCache[colName] = {
+                            __fieldName: colName,
+                            __dbColumnName: dbColumnName,
+                            __tableAlias: tableAlias, // Alias for SQL generation
+                            __sourceTable: sourceTable, // Actual table name for mapper lookup
+                            __mapper: mapper, // Include mapper for toDriver transformation in conditions
+                            __sqlType: columnSqlTypes[colName], // Column SQL type — lets flag* emit width-exact mask casts
+                            __navigationAliases: navigationAliases, // All intermediate navigation aliases for JOIN resolution
+                        };
                     }
-                    if (relConfig.type === 'many') {
-                        // Collection navigation
-                        // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
-                        Object.defineProperty(mock, relName, {
-                            get: () => {
+                    return cached;
+                },
+                enumerable: true,
+                configurable: true,
+            };
+        }
+        // Build extended navigation path for nested collections
+        // Only build navigation path if we have a sourceAlias (meaning we're inside a collection's selector)
+        // If sourceAlias is empty, we're in the main query and references are joined in the FROM clause
+        let extendedNavPath = [];
+        if (this.sourceAlias) {
+            // Build the current navigation step to include in path for nested collections
+            // This represents the join from sourceAlias to this.relationName (this.targetTable)
+            const currentNavStep = {
+                alias: this.relationName,
+                targetTable: this.targetTable,
+                foreignKeys: this.foreignKeys,
+                matches: this.matches.length > 0 ? this.matches : ['id'], // Default to 'id' if not specified
+                isMandatory: this.isMandatory,
+                sourceAlias: this.sourceAlias,
+            };
+            extendedNavPath = [...this.navigationPath, currentNavStep];
+        }
+        // Values captured at descriptor-build time — identical for every row of this
+        // signature (the registry is the process-wide schema registry; `sourceAlias`
+        // determines whether nested references track their join path).
+        const schemaRegistry = this.schemaRegistry;
+        const parentSourceAlias = this.sourceAlias;
+        // Add navigation properties (both collections and references)
+        if (this.targetTableSchema.relations) {
+            for (const [relName, relConfig] of Object.entries(this.targetTableSchema.relations)) {
+                // Try to get target schema from registry (preferred, has full relations) or targetTableBuilder
+                let nestedTargetSchema;
+                if (this.schemaRegistry) {
+                    nestedTargetSchema = this.schemaRegistry.get(relConfig.targetTable);
+                }
+                if (!nestedTargetSchema && relConfig.targetTableBuilder) {
+                    nestedTargetSchema = relConfig.targetTableBuilder.build();
+                }
+                if (relConfig.type === 'many') {
+                    // Collection navigation
+                    // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
+                    descriptors[relName] = {
+                        get() {
+                            const slots = this;
+                            const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
+                            // Memoize per row: selectors revisit the same navigation repeatedly
+                            // (aggregates, predicates), and each fresh visit used to rebuild the
+                            // whole sub-graph.
+                            let cached = navCache[relName];
+                            if (cached === undefined) {
                                 const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
-                                return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.relationName, // Use alias (relationName) for correlation in lateral joins
+                                cached = navCache[relName] = new CollectionQueryBuilder(relName, relConfig.targetTable, fk, tableAlias, // Use alias (relationName) for correlation in lateral joins
                                 nestedTargetSchema, // Pass the target schema directly
-                                this.schemaRegistry, // Pass schema registry for nested resolution
+                                schemaRegistry, // Pass schema registry for nested resolution
                                 extendedNavPath, // Pass navigation path for intermediate joins (empty if main query)
                                 relConfig.foreignKeys, // Propagate composite FK / literal predicates
                                 relConfig.matches);
-                            },
-                            enumerable: false,
-                            configurable: true,
-                        });
-                    }
-                    else {
-                        // Reference navigation
-                        // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow
-                        // with circular relations like User->Posts->User)
-                        Object.defineProperty(mock, relName, {
-                            get: () => {
+                            }
+                            return cached;
+                        },
+                        enumerable: false,
+                        configurable: true,
+                    };
+                }
+                else {
+                    // Reference navigation
+                    // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow
+                    // with circular relations like User->Posts->User)
+                    descriptors[relName] = {
+                        get() {
+                            const slots = this;
+                            const navCache = slots[MOCK_ROW_NAV_CACHE] ?? (slots[MOCK_ROW_NAV_CACHE] = {});
+                            let cached = navCache[relName];
+                            if (cached === undefined) {
                                 const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, nestedTargetSchema, // Pass the target schema directly
-                                this.schemaRegistry, // Pass schema registry for nested resolution
+                                schemaRegistry, // Pass schema registry for nested resolution
                                 extendedNavPath, // Pass navigation path for nested collections
-                                this.sourceAlias ? this.relationName : '' // Only set source if tracking path
+                                parentSourceAlias ? tableAlias : '' // Only set source if tracking path
                                 );
-                                return refBuilder.createMockTargetRow();
-                            },
-                            enumerable: false,
-                            configurable: true,
-                        });
-                    }
+                                cached = navCache[relName] = refBuilder.createMockTargetRow();
+                            }
+                            return cached;
+                        },
+                        enumerable: false,
+                        configurable: true,
+                    };
                 }
             }
-            return mock;
-        }
-        else {
-            // Fallback: use the shared nested proxy that supports deep property access
-            return createNestedFieldRefProxy(this.relationName);
         }
+        return descriptors;
     }
 }
 exports.ReferenceQueryBuilder = ReferenceQueryBuilder;