linkgress-orm 0.1.0 → 0.1.1

package/dist/query/query-builder.js

@@ -1,12 +1,117 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionQueryBuilder = exports.ReferenceQueryBuilder = exports.SelectQueryBuilder = exports.QueryBuilder = void 0;
+exports.getColumnNameMapForSchema = getColumnNameMapForSchema;
+exports.getRelationEntriesForSchema = getRelationEntriesForSchema;
+exports.getTargetSchemaForRelation = getTargetSchemaForRelation;
+exports.createNestedFieldRefProxy = createNestedFieldRefProxy;
 const conditions_1 = require("./conditions");
 const query_utils_1 = require("./query-utils");
 const subquery_1 = require("./subquery");
 const grouped_query_1 = require("./grouped-query");
 const cte_builder_1 = require("./cte-builder");
 const collection_strategy_factory_1 = require("./collection-strategy.factory");
+/**
+ * Performance utility: Get column name map from schema, using cached version if available
+ */
+function getColumnNameMapForSchema(schema) {
+    if (schema.columnNameMap) {
+        return schema.columnNameMap;
+    }
+    // Fallback: build the map (for schemas that weren't built with the new TableBuilder)
+    const map = new Map();
+    for (const [colName, colBuilder] of Object.entries(schema.columns)) {
+        map.set(colName, colBuilder.build().name);
+    }
+    return map;
+}
+/**
+ * Performance utility: Get relation entries array from schema, using cached version if available
+ */
+function getRelationEntriesForSchema(schema) {
+    if (schema.relationEntries) {
+        return schema.relationEntries;
+    }
+    // Fallback: build the array (for schemas that weren't built with the new TableBuilder)
+    return Object.entries(schema.relations);
+}
+/**
+ * Performance utility: Get target schema for a relation, using cached version if available
+ */
+function getTargetSchemaForRelation(schema, relName, relConfig) {
+    // Try cached version first
+    if (schema.relationSchemaCache) {
+        const cached = schema.relationSchemaCache.get(relName);
+        if (cached)
+            return cached;
+    }
+    // Fallback: build the schema
+    if (relConfig.targetTableBuilder) {
+        return relConfig.targetTableBuilder.build();
+    }
+    return undefined;
+}
+// Performance: Cache nested field ref proxies per table alias
+const nestedFieldRefProxyCache = new Map();
+/**
+ * Creates a nested proxy that supports accessing properties at any depth.
+ * This allows patterns like `p.product.priceMode` to work even without full schema information.
+ * Each property access returns an object that is both a FieldRef and can be further accessed.
+ *
+ * @param tableAlias The table alias to use for the FieldRef
+ * @returns A proxy that creates FieldRefs for any property access
+ */
+function createNestedFieldRefProxy(tableAlias) {
+    // Return cached proxy if available
+    const cached = nestedFieldRefProxyCache.get(tableAlias);
+    if (cached)
+        return cached;
+    const handler = {
+        get: (_target, prop) => {
+            // Handle Symbol.toPrimitive for string conversion (used in template literals)
+            if (prop === Symbol.toPrimitive || prop === 'toString' || prop === 'valueOf') {
+                return () => `[NestedFieldRefProxy:${tableAlias}]`;
+            }
+            if (typeof prop === 'symbol')
+                return undefined;
+            // Return an object that is both a FieldRef AND a proxy for further nesting
+            const fieldRef = {
+                __fieldName: prop,
+                __dbColumnName: prop,
+                __tableAlias: tableAlias,
+            };
+            // Return a proxy that acts as both the FieldRef and allows further property access
+            return new Proxy(fieldRef, {
+                get: (fieldTarget, nestedProp) => {
+                    // Handle Symbol.toPrimitive for string conversion (used in template literals)
+                    if (nestedProp === Symbol.toPrimitive || nestedProp === 'toString' || nestedProp === 'valueOf') {
+                        return () => fieldTarget.__dbColumnName;
+                    }
+                    if (typeof nestedProp === 'symbol')
+                        return undefined;
+                    // If accessing FieldRef properties, return them
+                    if (nestedProp === '__fieldName' || nestedProp === '__dbColumnName' || nestedProp === '__tableAlias') {
+                        return fieldTarget[nestedProp];
+                    }
+                    // Otherwise, treat as nested navigation and create a new nested proxy
+                    // The nested table alias is the property name (e.g., 'product' for p.product)
+                    return createNestedFieldRefProxy(prop)[nestedProp];
+                },
+                has: (_fieldTarget, _nestedProp) => true,
+            });
+        },
+        has: (_target, prop) => {
+            // The outer proxy doesn't have FieldRef properties - only field names
+            if (prop === '__fieldName' || prop === '__dbColumnName' || prop === '__tableAlias') {
+                return false;
+            }
+            return true;
+        },
+    };
+    const proxy = new Proxy({}, handler);
+    nestedFieldRefProxyCache.set(tableAlias, proxy);
+    return proxy;
+}
 /**
  * Cached regex for numeric string detection
  * Used to convert PostgreSQL NUMERIC/BIGINT strings to numbers
@@ -77,14 +182,10 @@ class QueryBuilder {
             return this._cachedMockRow;
         }
         const mock = {};
-        // Performance: Build column configs once and cache them
-        const columnEntries = Object.entries(this.schema.columns);
-        const columnConfigs = new Map();
-        for (const [colName, colBuilder] of columnEntries) {
-            columnConfigs.set(colName, colBuilder.build().name);
-        }
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(this.schema);
         // Add columns as FieldRef objects - type-safe with property name and database column name
-        for (const [colName, dbColumnName] of columnConfigs) {
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -95,17 +196,13 @@ class QueryBuilder {
                 configurable: true,
             });
         }
-        // Performance: Cache target schemas for relations to avoid repeated .build() calls
-        const relationSchemas = new Map();
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
-            if (relConfig.targetTableBuilder) {
-                relationSchemas.set(relName, relConfig.targetTableBuilder.build());
-            }
-        }
+        // Performance: Use pre-computed relation entries and cached schemas
+        const relationEntries = getRelationEntriesForSchema(this.schema);
         // Add relations (both collections and single references)
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
+        for (const [relName, relConfig] of relationEntries) {
+            // Performance: Use cached target schema
+            const targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
             if (relConfig.type === 'many') {
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema);
@@ -116,7 +213,6 @@ class QueryBuilder {
             }
             else {
                 // Single reference navigation (many-to-one, one-to-one)
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
@@ -234,14 +330,10 @@ class QueryBuilder {
      */
     createMockRowForTable(schema, alias) {
         const mock = {};
-        // Performance: Build column configs once and cache them
-        const columnEntries = Object.entries(schema.columns);
-        const columnConfigs = new Map();
-        for (const [colName, colBuilder] of columnEntries) {
-            columnConfigs.set(colName, colBuilder.build().name);
-        }
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(schema);
         // Add columns as FieldRef objects with table alias
-        for (const [colName, dbColumnName] of columnConfigs) {
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -252,18 +344,14 @@ class QueryBuilder {
                 configurable: true,
             });
         }
-        // Performance: Cache target schemas for relations
-        const relationSchemas = new Map();
-        for (const [relName, relConfig] of Object.entries(schema.relations)) {
-            if (relConfig.targetTableBuilder) {
-                relationSchemas.set(relName, relConfig.targetTableBuilder.build());
-            }
-        }
+        // Performance: Use pre-computed relation entries and cached schemas
+        const relationEntries = getRelationEntriesForSchema(schema);
         // Add navigation properties (single references and collections)
-        for (const [relName, relConfig] of Object.entries(schema.relations)) {
+        for (const [relName, relConfig] of relationEntries) {
+            // Performance: Use cached target schema
+            const targetSchema = getTargetSchemaForRelation(schema, relName, relConfig);
             if (relConfig.type === 'many') {
                 // Collection navigation
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
@@ -274,7 +362,6 @@ class QueryBuilder {
             }
             else {
                 // Single reference navigation
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
@@ -383,7 +470,12 @@ class SelectQueryBuilder {
      *   .toList();
      */
     with(...ctes) {
-        this.ctes.push(...ctes);
+        // Add CTEs, avoiding duplicates by name
+        for (const cte of ctes) {
+            if (!this.ctes.some(existing => existing.name === cte.name)) {
+                this.ctes.push(cte);
+            }
+        }
         return this;
     }
     /**
@@ -610,14 +702,10 @@ class SelectQueryBuilder {
      */
     createMockRowForTable(schema, alias) {
         const mock = {};
-        // Performance: Build column configs once and cache them
-        const columnEntries = Object.entries(schema.columns);
-        const columnConfigs = new Map();
-        for (const [colName, colBuilder] of columnEntries) {
-            columnConfigs.set(colName, colBuilder.build().name);
-        }
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(schema);
         // Add columns as FieldRef objects with table alias
-        for (const [colName, dbColumnName] of columnConfigs) {
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -628,18 +716,14 @@ class SelectQueryBuilder {
                 configurable: true,
             });
         }
-        // Performance: Cache target schemas for relations
-        const relationSchemas = new Map();
-        for (const [relName, relConfig] of Object.entries(schema.relations)) {
-            if (relConfig.targetTableBuilder) {
-                relationSchemas.set(relName, relConfig.targetTableBuilder.build());
-            }
-        }
+        // Performance: Use pre-computed relation entries and cached schemas
+        const relationEntries = getRelationEntriesForSchema(schema);
         // Add navigation properties (single references and collections)
-        for (const [relName, relConfig] of Object.entries(schema.relations)) {
+        for (const [relName, relConfig] of relationEntries) {
+            // Performance: Use cached target schema
+            const targetSchema = getTargetSchemaForRelation(schema, relName, relConfig);
             if (relConfig.type === 'many') {
                 // Collection navigation
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
@@ -650,7 +734,6 @@ class SelectQueryBuilder {
             }
             else {
                 // Single reference navigation
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
@@ -1238,9 +1321,10 @@ class SelectQueryBuilder {
      */
     createMockRow() {
         const mock = {};
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(this.schema);
         // Add columns as FieldRef objects - type-safe with property name and database column name
-        for (const [colName, colBuilder] of Object.entries(this.schema.columns)) {
-            const dbColumnName = colBuilder.build().name;
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -1257,13 +1341,12 @@ class SelectQueryBuilder {
             if (join.isSubquery || !join.schema) {
                 continue;
             }
-            for (const [colName, colBuilder] of Object.entries(join.schema.columns)) {
-                const dbColumnName = colBuilder.build().name;
-                // Create a unique property name by prefixing with table alias or using the column name directly
-                // For now, we'll create nested objects for each joined table
-                if (!mock[join.alias]) {
-                    mock[join.alias] = {};
-                }
+            // Performance: Use pre-computed column name map for joined schema
+            const joinColumnNameMap = getColumnNameMapForSchema(join.schema);
+            if (!mock[join.alias]) {
+                mock[join.alias] = {};
+            }
+            for (const [colName, dbColumnName] of joinColumnNameMap) {
                 Object.defineProperty(mock[join.alias], colName, {
                     get: () => ({
                         __fieldName: colName,
@@ -1275,15 +1358,18 @@ class SelectQueryBuilder {
                 });
             }
         }
+        // Performance: Use pre-computed relation entries
+        const relationEntries = getRelationEntriesForSchema(this.schema);
         // Add relations as CollectionQueryBuilder or ReferenceQueryBuilder
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
-            // Try to get target schema from registry (preferred, has full relations) or targetTableBuilder
+        for (const [relName, relConfig] of relationEntries) {
+            // Try to get target schema from registry (preferred, has full relations) or cached schema
             let targetSchema;
             if (this.schemaRegistry) {
                 targetSchema = this.schemaRegistry.get(relConfig.targetTable);
             }
-            if (!targetSchema && relConfig.targetTableBuilder) {
-                targetSchema = relConfig.targetTableBuilder.build();
+            if (!targetSchema) {
+                // Performance: Use cached target schema
+                targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
             }
             if (relConfig.type === 'many') {
                 Object.defineProperty(mock, relName, {
@@ -1384,27 +1470,13 @@ class SelectQueryBuilder {
         for (const [key, value] of Object.entries(selection)) {
             if (value && typeof value === 'object' && '__tableAlias' in value && '__dbColumnName' in value) {
                 // This is a FieldRef with a table alias - check if it's from a related table
-                const tableAlias = value.__tableAlias;
-                if (tableAlias !== this.schema.name && !joins.some(j => j.alias === tableAlias)) {
-                    // This references a related table - find the relation and add a JOIN
-                    const relation = this.schema.relations[tableAlias];
-                    if (relation && relation.type === 'one') {
-                        // Get target schema from targetTableBuilder if available
-                        let targetSchema;
-                        if (relation.targetTableBuilder) {
-                            const targetTableSchema = relation.targetTableBuilder.build();
-                            targetSchema = targetTableSchema.schema;
-                        }
-                        // Add a JOIN for this reference
-                        joins.push({
-                            alias: tableAlias,
-                            targetTable: relation.targetTable,
-                            targetSchema,
-                            foreignKeys: relation.foreignKeys || [relation.foreignKey || ''],
-                            matches: relation.matches || [],
-                            isMandatory: relation.isMandatory ?? false,
-                        });
-                    }
+                this.addJoinForFieldRef(value, joins);
+            }
+            else if (value instanceof conditions_1.SqlFragment) {
+                // SqlFragment may contain navigation property references - extract them
+                const fieldRefs = value.getFieldRefs();
+                for (const fieldRef of fieldRefs) {
+                    this.addJoinForFieldRef(fieldRef, joins);
                 }
             }
             else if (value && typeof value === 'object' && !Array.isArray(value)) {
@@ -1413,6 +1485,36 @@ class SelectQueryBuilder {
             }
         }
     }
+    /**
+     * Add a JOIN for a FieldRef if it references a related table
+     */
+    addJoinForFieldRef(fieldRef, joins) {
+        if (!fieldRef || typeof fieldRef !== 'object' || !('__tableAlias' in fieldRef) || !('__dbColumnName' in fieldRef)) {
+            return;
+        }
+        const tableAlias = fieldRef.__tableAlias;
+        if (tableAlias && tableAlias !== this.schema.name && !joins.some(j => j.alias === tableAlias)) {
+            // This references a related table - find the relation and add a JOIN
+            const relation = this.schema.relations[tableAlias];
+            if (relation && relation.type === 'one') {
+                // Get target schema from targetTableBuilder if available
+                let targetSchema;
+                if (relation.targetTableBuilder) {
+                    const targetTableSchema = relation.targetTableBuilder.build();
+                    targetSchema = targetTableSchema.schema;
+                }
+                // Add a JOIN for this reference
+                joins.push({
+                    alias: tableAlias,
+                    targetTable: relation.targetTable,
+                    targetSchema,
+                    foreignKeys: relation.foreignKeys || [relation.foreignKey || ''],
+                    matches: relation.matches || [],
+                    isMandatory: relation.isMandatory ?? false,
+                });
+            }
+        }
+    }
     /**
      * Detect navigation property references in a WHERE condition and add necessary JOINs
      */
@@ -1599,9 +1701,10 @@ class SelectQueryBuilder {
                                 // Select all columns from the target table and group them
                                 // We'll need to use JSON object building in SQL
                                 const fieldParts = [];
-                                for (const [colKey, col] of Object.entries(targetSchema.columns)) {
-                                    const config = col.build();
-                                    fieldParts.push(`'${colKey}', "${alias}"."${config.name}"`);
+                                // Performance: Use cached column name map
+                                const targetColMap = getColumnNameMapForSchema(targetSchema);
+                                for (const [colKey, dbColName] of targetColMap) {
+                                    fieldParts.push(`'${colKey}', "${alias}"."${dbColName}"`);
                                 }
                                 selectParts.push(`json_build_object(${fieldParts.join(', ')}) as "${key}"`);
                             }
@@ -1631,11 +1734,8 @@ class SelectQueryBuilder {
                                             const relConfig = this.schema.relations[alias];
                                             if (relConfig && relConfig.type === 'one') {
                                                 // This is a reference navigation - select all fields from the target table
-                                                // Find the target table schema
-                                                let targetSchema;
-                                                if (relConfig.targetTableBuilder) {
-                                                    targetSchema = relConfig.targetTableBuilder.build();
-                                                }
+                                                // Performance: Use cached target schema
+                                                const targetSchema = getTargetSchemaForRelation(this.schema, alias, relConfig);
                                                 if (targetSchema) {
                                                     // Add JOIN if not already added
                                                     if (!joins.find(j => j.alias === alias)) {
@@ -1654,9 +1754,10 @@ class SelectQueryBuilder {
                                                     }
                                                     // Select all columns from the target table and group them into a JSON object
                                                     const fieldParts = [];
-                                                    for (const [colKey, col] of Object.entries(targetSchema.columns)) {
-                                                        const config = col.build();
-                                                        fieldParts.push(`'${colKey}', "${alias}"."${config.name}"`);
+                                                    // Performance: Use cached column name map
+                                                    const targetColMap = getColumnNameMapForSchema(targetSchema);
+                                                    for (const [colKey, dbColName] of targetColMap) {
+                                                        fieldParts.push(`'${colKey}', "${alias}"."${dbColName}"`);
                                                     }
                                                     selectParts.push(`json_build_object(${fieldParts.join(', ')}) as "${key}"`);
                                                     continue;
@@ -2301,9 +2402,9 @@ class ReferenceQueryBuilder {
     createMockTargetRow() {
         if (this.targetTableSchema) {
             const mock = {};
-            // Add columns
-            for (const [colName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
-                const dbColumnName = colBuilder.build().name;
+            // Add columns - use pre-computed column name map if available
+            const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
+            for (const [colName, dbColumnName] of columnNameMap) {
                 Object.defineProperty(mock, colName, {
                     get: () => ({
                         __fieldName: colName,
@@ -2356,15 +2457,8 @@ class ReferenceQueryBuilder {
             return mock;
         }
         else {
-            // Fallback: generic proxy
-            const handler = {
-                get: (target, prop) => ({
-                    __fieldName: prop,
-                    __dbColumnName: prop,
-                    __tableAlias: this.relationName,
-                }),
-            };
-            return new Proxy({}, handler);
+            // Fallback: use the shared nested proxy that supports deep property access
+            return createNestedFieldRefProxy(this.relationName);
         }
     }
 }
@@ -2444,14 +2538,10 @@ class CollectionQueryBuilder {
         if (this.targetTableSchema) {
             // If we have schema information, create a properly typed mock
             const mock = {};
-            // Performance: Build column configs once and cache them
-            const columnEntries = Object.entries(this.targetTableSchema.columns);
-            const columnConfigs = new Map();
-            for (const [colName, colBuilder] of columnEntries) {
-                columnConfigs.set(colName, colBuilder.build().name);
-            }
+            // Performance: Use pre-computed column name map if available
+            const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
             // Add columns
-            for (const [colName, dbColumnName] of columnConfigs) {
+            for (const [colName, dbColumnName] of columnNameMap) {
                 Object.defineProperty(mock, colName, {
                     get: () => ({
                         __fieldName: colName,
@@ -2500,14 +2590,8 @@ class CollectionQueryBuilder {
             return mock;
         }
         else {
-            // Fallback: generic proxy (don't cache as it's dynamic)
-            const handler = {
-                get: (target, prop) => ({
-                    __fieldName: prop,
-                    __dbColumnName: prop,
-                }),
-            };
-            return new Proxy({}, handler);
+            // Fallback: use the shared nested proxy that supports deep property access
+            return createNestedFieldRefProxy(this.targetTable);
         }
     }
     /**
@@ -2724,9 +2808,9 @@ class CollectionQueryBuilder {
         else {
             // No selector - select all fields from the target table schema
             if (this.targetTableSchema && this.targetTableSchema.columns) {
-                for (const [colName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
-                    const colConfig = colBuilder.build ? colBuilder.build() : colBuilder;
-                    const dbColumnName = colConfig.name || colName;
+                // Performance: Use cached column name map
+                const colNameMap = getColumnNameMapForSchema(this.targetTableSchema);
+                for (const [colName, dbColumnName] of colNameMap) {
                     selectedFieldConfigs.push({
                         alias: colName,
                         expression: `"${dbColumnName}"`,
@@ -2756,13 +2840,11 @@ class CollectionQueryBuilder {
         // Step 3: Build ORDER BY clause SQL (without ORDER BY keyword)
         let orderByClause;
         if (this.orderByFields.length > 0) {
+            // Performance: Pre-compute column name map for ORDER BY lookups
+            const colNameMap = this.targetTableSchema ? getColumnNameMapForSchema(this.targetTableSchema) : null;
             const orderParts = this.orderByFields.map(({ field, direction }) => {
-                // Look up the database column name from the schema if available
-                let dbColumnName = field;
-                if (this.targetTableSchema && this.targetTableSchema.columns[field]) {
-                    const colBuilder = this.targetTableSchema.columns[field];
-                    dbColumnName = colBuilder.build().name;
-                }
+                // Look up the database column name from the cached map if available
+                const dbColumnName = colNameMap?.get(field) ?? field;
                 return `"${dbColumnName}" ${direction}`;
             });
             orderByClause = orderParts.join(', ');