linkgress-orm 0.1.16 → 0.1.18

package/dist/query/query-builder.js

@@ -27,6 +27,7 @@ var FieldType;
     FieldType[FieldType["FIELD_REF_MAPPER"] = 6] = "FIELD_REF_MAPPER";
     FieldType[FieldType["FIELD_REF_NO_MAPPER"] = 7] = "FIELD_REF_NO_MAPPER";
     FieldType[FieldType["SIMPLE"] = 8] = "SIMPLE";
+    FieldType[FieldType["COLLECTION_SINGLE"] = 9] = "COLLECTION_SINGLE";
 })(FieldType || (FieldType = {}));
 /**
  * Performance utility: Get column name map from schema, using cached version if available
@@ -175,7 +176,7 @@ class QueryBuilder {
      * Multiple where() calls are chained with AND logic
      */
     where(condition) {
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         const newCondition = condition(mockRow);
         if (this.whereCond) {
             this.whereCond = (0, conditions_1.and)(this.whereCond, newCondition);
@@ -194,8 +195,9 @@ class QueryBuilder {
     }
     /**
      * Create mock row for analysis
+     * @internal - Also used by DbEntityTable.props() to avoid code duplication
      */
-    createMockRow() {
+    _createMockRow() {
         // Performance: Return cached mock if available
         if (this._cachedMockRow) {
             return this._cachedMockRow;
@@ -293,7 +295,7 @@ class QueryBuilder {
         const rightAlias = `${rightSchema.name}_${this.joinCounter}`;
         const newJoinCounter = this.joinCounter + 1;
         // Create mock rows for condition evaluation
-        const mockLeft = this.createMockRow();
+        const mockLeft = this._createMockRow();
         const mockRight = this.createMockRowForTable(rightSchema, rightAlias);
         const joinCondition = condition(mockLeft, mockRight);
         // Add the join to the list
@@ -306,7 +308,7 @@ class QueryBuilder {
             }];
         // Store schemas for creating fresh mocks in the selector
         const leftSchema = this.schema;
-        const createLeftMock = () => this.createMockRow();
+        const createLeftMock = () => this._createMockRow();
         const createRightMock = () => this.createMockRowForTable(rightSchema, rightAlias);
         // Create a selector wrapper that generates fresh mocks and calls the user's selector
         const wrappedSelector = (row) => {
@@ -342,7 +344,7 @@ class QueryBuilder {
         const rightAlias = `${rightSchema.name}_${this.joinCounter}`;
         const newJoinCounter = this.joinCounter + 1;
         // Create mock rows for condition evaluation
-        const mockLeft = this.createMockRow();
+        const mockLeft = this._createMockRow();
         const mockRight = this.createMockRowForTable(rightSchema, rightAlias);
         const joinCondition = condition(mockLeft, mockRight);
         // Add the join to the list
@@ -355,7 +357,7 @@ class QueryBuilder {
             }];
         // Store schemas for creating fresh mocks in the selector
         const leftSchema = this.schema;
-        const createLeftMock = () => this.createMockRow();
+        const createLeftMock = () => this._createMockRow();
         const createRightMock = () => this.createMockRowForTable(rightSchema, rightAlias);
         // Create a selector wrapper that generates fresh mocks and calls the user's selector
         const wrappedSelector = (row) => {
@@ -441,7 +443,7 @@ class QueryBuilder {
         return this;
     }
     orderBy(selector) {
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         const result = selector(mockRow);
         (0, query_utils_1.parseOrderBy)(result, this.orderByFields);
         return this;
@@ -497,7 +499,7 @@ class SelectQueryBuilder {
      * Note: The row parameter represents the selected shape (after select())
      */
     where(condition) {
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         // Apply the selector to get the selected shape that the user sees in the WHERE condition
         const selectedMock = this.selector(mockRow);
         // Wrap in proxy - for WHERE, we preserve original column names
@@ -545,7 +547,7 @@ class SelectQueryBuilder {
         return this;
     }
     orderBy(selector) {
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         const selectedMock = this.selector(mockRow);
         // Wrap selectedMock in a proxy that returns FieldRefs for property access
         const fieldRefProxy = this.createFieldRefProxy(selectedMock);
@@ -577,7 +579,7 @@ class SelectQueryBuilder {
     leftJoinSubquery(subquery, alias, condition, selector) {
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         const mockLeftSelection = this.selector(mockRow);
         // Create mock for the subquery result (right side)
         // For subqueries, we create a mock based on the result type
@@ -621,7 +623,7 @@ class SelectQueryBuilder {
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
         // IMPORTANT: We call the selector with the mock row to get a result that contains FieldRef objects
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         const mockLeftSelection = this.selector(mockRow);
         // The mockLeftSelection now contains FieldRef objects (with __fieldName, __dbColumnName, __tableAlias)
         // These FieldRef objects preserve the table context
@@ -652,7 +654,7 @@ class SelectQueryBuilder {
     leftJoinCte(cte, condition, selector) {
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         const mockLeftSelection = this.selector(mockRow);
         // Create mock for the CTE columns (right side)
         const mockRight = this.createMockRowForCte(cte);
@@ -685,7 +687,7 @@ class SelectQueryBuilder {
     innerJoinSubquery(subquery, alias, condition, selector) {
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         const mockLeftSelection = this.selector(mockRow);
         // Create mock for the subquery result (right side)
         const mockRight = this.createMockRowForSubquery(alias, subquery);
@@ -727,7 +729,7 @@ class SelectQueryBuilder {
         const rightAlias = `${rightSchema.name}_${this.joinCounter}`;
         const newJoinCounter = this.joinCounter + 1;
         // Create mock for the current selection (left side)
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         const mockLeftSelection = this.selector(mockRow);
         // Create mock for the right table
         const mockRight = this.createMockRowForTable(rightSchema, rightAlias);
@@ -936,13 +938,13 @@ class SelectQueryBuilder {
         // If selector is provided, apply it to determine the field
         let fieldToAggregate;
         if (selector) {
-            const mockRow = this.createMockRow();
+            const mockRow = this._createMockRow();
             const mockSelection = this.selector(mockRow);
             fieldToAggregate = selector(mockSelection);
         }
         else {
             // No selector - use the current selection
-            const mockRow = this.createMockRow();
+            const mockRow = this._createMockRow();
             fieldToAggregate = this.selector(mockRow);
         }
         // Build aggregation query
@@ -967,13 +969,13 @@ class SelectQueryBuilder {
         // If selector is provided, apply it to determine the field
         let fieldToAggregate;
         if (selector) {
-            const mockRow = this.createMockRow();
+            const mockRow = this._createMockRow();
             const mockSelection = this.selector(mockRow);
             fieldToAggregate = selector(mockSelection);
         }
         else {
             // No selector - use the current selection
-            const mockRow = this.createMockRow();
+            const mockRow = this._createMockRow();
             fieldToAggregate = this.selector(mockRow);
         }
         // Build aggregation query
@@ -998,13 +1000,13 @@ class SelectQueryBuilder {
         // If selector is provided, apply it to determine the field
         let fieldToAggregate;
         if (selector) {
-            const mockRow = this.createMockRow();
+            const mockRow = this._createMockRow();
             const mockSelection = this.selector(mockRow);
             fieldToAggregate = selector(mockSelection);
         }
         else {
             // No selector - use the current selection
-            const mockRow = this.createMockRow();
+            const mockRow = this._createMockRow();
             fieldToAggregate = this.selector(mockRow);
         }
         // Build aggregation query
@@ -1052,7 +1054,7 @@ class SelectQueryBuilder {
             executor: this.executor,
         }));
         // Analyze the selector to extract nested queries
-        const mockRow = tracer.trace('createMockRow', () => this.createMockRow());
+        const mockRow = tracer.trace('createMockRow', () => this._createMockRow());
         const selectionResult = tracer.trace('evaluateSelector', () => this.selector(mockRow));
         // Check if we're using temp table strategy and have collections
         const collections = tracer.trace('detectCollections', () => this.detectCollections(selectionResult));
@@ -1319,7 +1321,7 @@ class SelectQueryBuilder {
         const baseSelection = {};
         const collectionNames = new Set(collections.map(c => c.name));
         // Always ensure we have the primary key in the base selection with a known alias
-        const mockRow = this.createMockRow();
+        const mockRow = this._createMockRow();
         baseSelection['__pk_id'] = mockRow.id; // Add primary key with a known alias
         for (const [key, value] of Object.entries(selection)) {
             if (!collectionNames.has(key)) {
@@ -1413,6 +1415,10 @@ class SelectQueryBuilder {
             // Array aggregation
             return [];
         }
+        else if (builder.isSingleResult()) {
+            // firstOrDefault() - single item
+            return null;
+        }
         else {
             // JSONB aggregation (object array)
             return [];
@@ -1441,10 +1447,215 @@ class SelectQueryBuilder {
         }
         return result;
     }
+    /**
+     * Delete records matching the current WHERE condition
+     * Returns a fluent builder that can be awaited directly or chained with .returning()
+     *
+     * @example
+     * ```typescript
+     * // No returning (default) - returns void
+     * await db.users.where(u => eq(u.id, 1)).delete();
+     *
+     * // With returning() - returns full entities
+     * const deleted = await db.users.where(u => eq(u.id, 1)).delete().returning();
+     *
+     * // With returning(selector) - returns selected columns
+     * const results = await db.users.where(u => eq(u.isActive, false)).delete()
+     *   .returning(u => ({ id: u.id, username: u.username }));
+     * ```
+     */
+    delete() {
+        const queryBuilder = this;
+        const executeDelete = async (returning) => {
+            // Build WHERE clause
+            if (!queryBuilder.whereCond) {
+                throw new Error('Delete requires a WHERE condition. Use where() before delete().');
+            }
+            const condBuilder = new conditions_1.ConditionBuilder();
+            const { sql: whereSql, params: whereParams } = condBuilder.build(queryBuilder.whereCond, 1);
+            // Build RETURNING clause
+            const returningClause = queryBuilder.buildDeleteReturningClause(returning);
+            const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
+            let sql = `DELETE FROM ${qualifiedTableName} WHERE ${whereSql}`;
+            if (returningClause) {
+                sql += ` RETURNING ${returningClause.sql}`;
+            }
+            const result = queryBuilder.executor
+                ? await queryBuilder.executor.query(sql, whereParams)
+                : await queryBuilder.client.query(sql, whereParams);
+            if (!returningClause) {
+                return undefined;
+            }
+            return queryBuilder.mapDeleteReturningResults(result.rows, returning);
+        };
+        return {
+            then(onfulfilled, onrejected) {
+                return executeDelete(undefined).then(onfulfilled, onrejected);
+            },
+            returning(selector) {
+                const returningConfig = selector ?? true;
+                return {
+                    then(onfulfilled, onrejected) {
+                        return executeDelete(returningConfig).then(onfulfilled, onrejected);
+                    }
+                };
+            }
+        };
+    }
+    /**
+     * Update records matching the current WHERE condition
+     * Returns a fluent builder that can be awaited directly or chained with .returning()
+     *
+     * @param data Partial data to update
+     *
+     * @example
+     * ```typescript
+     * // No returning (default) - returns void
+     * await db.users.where(u => eq(u.id, 1)).update({ age: 30 });
+     *
+     * // With returning() - returns full entities
+     * const updated = await db.users.where(u => eq(u.id, 1)).update({ age: 30 }).returning();
+     *
+     * // With returning(selector) - returns selected columns
+     * const results = await db.users.where(u => eq(u.isActive, true)).update({ lastLogin: new Date() })
+     *   .returning(u => ({ id: u.id, lastLogin: u.lastLogin }));
+     * ```
+     */
+    update(data) {
+        const queryBuilder = this;
+        const executeUpdate = async (returning) => {
+            // Build WHERE clause
+            if (!queryBuilder.whereCond) {
+                throw new Error('Update requires a WHERE condition. Use where() before update().');
+            }
+            // Build SET clause
+            const setClauses = [];
+            const values = [];
+            let paramIndex = 1;
+            for (const [key, value] of Object.entries(data)) {
+                const column = queryBuilder.schema.columns[key];
+                if (column) {
+                    const config = column.build();
+                    setClauses.push(`"${config.name}" = $${paramIndex++}`);
+                    // Apply toDriver mapper if present
+                    const mappedValue = config.mapper
+                        ? config.mapper.toDriver(value)
+                        : value;
+                    values.push(mappedValue);
+                }
+            }
+            if (setClauses.length === 0) {
+                throw new Error('No valid columns to update');
+            }
+            const condBuilder = new conditions_1.ConditionBuilder();
+            const { sql: whereSql, params: whereParams } = condBuilder.build(queryBuilder.whereCond, paramIndex);
+            values.push(...whereParams);
+            // Build RETURNING clause
+            const returningClause = queryBuilder.buildDeleteReturningClause(returning);
+            const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
+            let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')} WHERE ${whereSql}`;
+            if (returningClause) {
+                sql += ` RETURNING ${returningClause.sql}`;
+            }
+            const result = queryBuilder.executor
+                ? await queryBuilder.executor.query(sql, values)
+                : await queryBuilder.client.query(sql, values);
+            if (!returningClause) {
+                return undefined;
+            }
+            return queryBuilder.mapDeleteReturningResults(result.rows, returning);
+        };
+        return {
+            then(onfulfilled, onrejected) {
+                return executeUpdate(undefined).then(onfulfilled, onrejected);
+            },
+            returning(selector) {
+                const returningConfig = selector ?? true;
+                return {
+                    then(onfulfilled, onrejected) {
+                        return executeUpdate(returningConfig).then(onfulfilled, onrejected);
+                    }
+                };
+            }
+        };
+    }
+    /**
+     * Build RETURNING clause for delete/update operations
+     * @internal
+     */
+    buildDeleteReturningClause(returning) {
+        if (returning === undefined) {
+            return null;
+        }
+        if (returning === true) {
+            // Return all columns
+            const columns = Object.values(this.schema.columns).map(col => col.build().name);
+            const sql = columns.map(name => `"${name}"`).join(', ');
+            return { sql, columns };
+        }
+        // Selector function - extract selected columns
+        const mockRow = this._createMockRow();
+        const selectedMock = this.selector(mockRow);
+        const selection = returning(selectedMock);
+        if (typeof selection === 'object' && selection !== null) {
+            const columns = [];
+            const sqlParts = [];
+            for (const [alias, field] of Object.entries(selection)) {
+                if (field && typeof field === 'object' && '__dbColumnName' in field) {
+                    const dbName = field.__dbColumnName;
+                    columns.push(alias);
+                    sqlParts.push(`"${dbName}" AS "${alias}"`);
+                }
+            }
+            return { sql: sqlParts.join(', '), columns };
+        }
+        return null;
+    }
+    /**
+     * Map row results for delete/update RETURNING clause
+     * @internal
+     */
+    mapDeleteReturningResults(rows, returning) {
+        if (returning === true) {
+            // Full entity mapping - apply fromDriver mappers
+            return rows.map(row => {
+                const mapped = {};
+                for (const [propName, colBuilder] of Object.entries(this.schema.columns)) {
+                    const config = colBuilder.build();
+                    const dbValue = row[config.name];
+                    mapped[propName] = config.mapper ? config.mapper.fromDriver(dbValue) : dbValue;
+                }
+                return mapped;
+            });
+        }
+        // For selector functions, rows are already in the correct shape
+        // Just apply any type mappers needed
+        return rows.map(row => {
+            const mapped = {};
+            for (const [key, value] of Object.entries(row)) {
+                // Try to find column by alias or name
+                const colEntry = Object.entries(this.schema.columns).find(([propName, col]) => {
+                    const config = col.build();
+                    return propName === key || config.name === key;
+                });
+                if (colEntry) {
+                    const [, col] = colEntry;
+                    const config = col.build();
+                    // Apply fromDriver mapper if present
+                    mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
+                }
+                else {
+                    mapped[key] = value;
+                }
+            }
+            return mapped;
+        });
+    }
     /**
      * Create mock row for analysis
+     * @internal
      */
-    createMockRow() {
+    _createMockRow() {
         const mock = {};
         const tableAlias = this.schema.name;
         // Performance: Use pre-computed column name map if available
@@ -2232,9 +2443,18 @@ class SelectQueryBuilder {
                 }
                 else {
                     const isArrayAgg = value && typeof value === 'object' && 'isArrayAggregation' in value && value.isArrayAggregation();
+                    const isSingleResult = value instanceof CollectionQueryBuilder && value.isSingleResult();
                     if (isArrayAgg) {
                         fieldConfigs.push({ key, type: 2 /* FieldType.COLLECTION_ARRAY */, value });
                     }
+                    else if (isSingleResult) {
+                        fieldConfigs.push({
+                            key,
+                            type: 9 /* FieldType.COLLECTION_SINGLE */,
+                            value,
+                            collectionBuilder: value
+                        });
+                    }
                     else {
                         fieldConfigs.push({
                             key,
@@ -2345,6 +2565,18 @@ class SelectQueryBuilder {
                         }
                         break;
                     }
+                    case 9 /* FieldType.COLLECTION_SINGLE */: {
+                        // firstOrDefault() - return first item or null
+                        const items = rawValue || [];
+                        if (config.collectionBuilder && items.length > 0) {
+                            const transformedItems = this.transformCollectionItems(items, config.collectionBuilder);
+                            result[key] = transformedItems[0] ?? null;
+                        }
+                        else {
+                            result[key] = items[0] ?? null;
+                        }
+                        break;
+                    }
                     case 4 /* FieldType.CTE_AGGREGATION */: {
                         const items = rawValue || [];
                         if (config.innerMetadata && !disableMappers) {
@@ -2647,7 +2879,7 @@ class SelectQueryBuilder {
                 executor: this.executor,
             };
             // Analyze the selector to extract nested queries
-            const mockRow = this.createMockRow();
+            const mockRow = this._createMockRow();
             const selectionResult = this.selector(mockRow);
             // Build the query
             const { sql } = this.buildQuery(selectionResult, context);
@@ -2658,7 +2890,7 @@ class SelectQueryBuilder {
         // For table subqueries, preserve the selection metadata (includes SqlFragments with mappers)
         let selectionMetadata;
         if (mode === 'table') {
-            const mockRow = this.createMockRow();
+            const mockRow = this._createMockRow();
             selectionMetadata = this.selector(mockRow);
         }
         // Extract outer field refs from the WHERE condition
@@ -3078,6 +3310,18 @@ class CollectionQueryBuilder {
         // At runtime, this is still a CollectionQueryBuilder, but TypeScript sees it as CollectionResult
         return this;
     }
+    /**
+     * Get first item from collection or null if empty
+     * Automatically applies LIMIT 1 and returns a single item instead of array
+     */
+    firstOrDefault(name) {
+        if (name) {
+            this.asName = name;
+        }
+        this.limitValue = 1;
+        this.isMarkedAsList = false; // Single item, not a list
+        return this;
+    }
     /**
      * Get target table schema
      */
@@ -3096,6 +3340,12 @@ class CollectionQueryBuilder {
     isScalarAggregation() {
         return this.aggregationType !== undefined;
     }
+    /**
+     * Check if this is a single item result (firstOrDefault)
+     */
+    isSingleResult() {
+        return !this.isMarkedAsList && this.limitValue === 1;
+    }
     /**
      * Get the aggregation type
      */