linkgress-orm 0.1.18 → 0.1.20

package/dist/entity/db-context.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseContext = exports.DbEntityTable = exports.EntityInsertBuilder = exports.DataContext = exports.TableAccessor = exports.InsertBuilder = exports.QueryExecutor = exports.TimeTracer = void 0;
+const database_client_interface_1 = require("../database/database-client.interface");
 const entity_base_1 = require("./entity-base");
 const model_config_1 = require("./model-config");
 const query_builder_1 = require("../query/query-builder");
@@ -528,15 +529,21 @@ class TableAccessor {
             const column = this.schema.columns[key];
             if (column) {
                 const config = column.build();
-                if (!config.autoIncrement) {
-                    columns.push(`"${config.name}"`);
-                    // Apply toDriver mapper if present
-                    const mappedValue = config.mapper
-                        ? config.mapper.toDriver(value)
-                        : value;
-                    values.push(mappedValue);
-                    placeholders.push(`$${paramIndex++}`);
+                // Skip auto-increment columns
+                if (config.autoIncrement) {
+                    continue;
+                }
+                // Skip columns with undefined values if they have a default - let the DB use the default
+                if (value === undefined && (config.default !== undefined || config.identity)) {
+                    continue;
                 }
+                columns.push(`"${config.name}"`);
+                // Apply toDriver mapper if present
+                const mappedValue = config.mapper
+                    ? config.mapper.toDriver(value)
+                    : value;
+                values.push(mappedValue);
+                placeholders.push(`$${paramIndex++}`);
             }
         }
         const returningColumns = (0, sql_utils_1.buildReturningColumnList)(this.schema);
@@ -792,13 +799,18 @@ class DataContext {
     }
     /**
      * Get table accessor by name
+     * When in a transaction, creates a fresh accessor with the transactional client
      */
     getTable(name) {
-        const accessor = this.tableAccessors.get(name);
-        if (!accessor) {
+        const cachedAccessor = this.tableAccessors.get(name);
+        if (!cachedAccessor) {
             throw new Error(`Table ${String(name)} not found in schema`);
         }
-        return accessor;
+        // If in a transaction, create a new accessor with the current (transactional) client
+        if (this.client.isInTransaction()) {
+            return new TableAccessor(cachedAccessor.tableBuilder, this.client, this.schemaRegistry, this.executor, this.queryOptions?.collectionStrategy);
+        }
+        return cachedAccessor;
     }
     /**
      * Execute raw SQL query with optional type parameter for results
@@ -821,22 +833,25 @@ class DataContext {
     }
     /**
      * Execute in transaction
+     * Uses the database client's native transaction support for proper handling
+     * across different drivers (pg uses BEGIN/COMMIT, postgres uses sql.begin())
      */
     async transaction(fn) {
-        const connection = await this.client.connect();
-        try {
-            await connection.query('BEGIN');
-            const result = await fn(this);
-            await connection.query('COMMIT');
-            return result;
-        }
-        catch (error) {
-            await connection.query('ROLLBACK');
-            throw error;
-        }
-        finally {
-            connection.release();
-        }
+        // Store the original client
+        const originalClient = this.client;
+        return await this.client.transaction(async (queryFn) => {
+            // Create a transactional client that routes all queries through the transaction
+            const txClient = new database_client_interface_1.TransactionalClient(queryFn, originalClient);
+            // Temporarily swap the client to use the transactional one
+            this.client = txClient;
+            try {
+                return await fn(this);
+            }
+            finally {
+                // Restore the original client
+                this.client = originalClient;
+            }
+        });
     }
     /**
      * Get schema manager for create/drop operations and automatic migrations
@@ -977,6 +992,36 @@ class DbEntityTable {
         }
         return columns;
     }
+    /**
+     * Get an array of all column property names (keys) for this entity.
+     * Returns a strongly typed array where each element is a valid column key of TEntity.
+     *
+     * This is a convenience method equivalent to `getColumns().map(c => c.propertyName)`
+     * but with better type inference.
+     *
+     * @returns Array of column property names typed as ExtractDbColumnKeys<TEntity>
+     *
+     * @example
+     * ```typescript
+     * // Get all column keys
+     * const keys = db.users.getColumnKeys();
+     * // Type: ExtractDbColumnKeys<User>[] which is ('id' | 'username' | 'email' | ...)[]
+     *
+     * // Use for dynamic property access
+     * const user = await db.users.findOne(u => eq(u.id, 1));
+     * for (const key of db.users.getColumnKeys()) {
+     *   console.log(`${key}: ${user[key]}`); // TypeScript knows key is valid
+     * }
+     *
+     * // Use for building dynamic queries
+     * const columnKeys = db.users.getColumnKeys();
+     * // columnKeys[0] is typed as 'id' | 'username' | 'email' | ...
+     * ```
+     */
+    getColumnKeys() {
+        const schema = this._getSchema();
+        return Object.keys(schema.columns);
+    }
     /**
      * Get an object containing all entity properties as DbColumn references.
      * Useful for building dynamic queries or accessing column metadata.
@@ -1225,21 +1270,20 @@ class DbEntityTable {
      */
     where(condition) {
         const schema = this._getSchema();
-        // Create a selector that selects all columns with navigation property access
+        // Create a selector that selects all columns only (not navigation properties)
         const allColumnsSelector = (e) => {
             const result = {};
             // Copy all column properties
             for (const colName of Object.keys(schema.columns)) {
                 result[colName] = e[colName];
             }
-            // Add navigation properties as enumerable getters
-            // The getter returns the actual navigation builder (CollectionQueryBuilder/ReferenceQueryBuilder)
-            // which allows chained selectors like .select(u => ({ posts: u.posts!.where(...) }))
-            // When the selection is analyzed, the builder is detected and handled appropriately
+            // Add navigation properties as non-enumerable getters
+            // This allows chained selectors like .select(u => ({ posts: u.posts!.where(...) }))
+            // but they won't be included in the default query output
             for (const relName of Object.keys(schema.relations)) {
                 Object.defineProperty(result, relName, {
                     get: () => e[relName],
-                    enumerable: true, // Enumerable so it's included in Object.entries
+                    enumerable: false, // Non-enumerable so it's NOT included in default selection
                     configurable: true,
                 });
             }
@@ -1255,21 +1299,20 @@ class DbEntityTable {
      */
     with(...ctes) {
         const schema = this._getSchema();
-        // Create a selector that selects all columns with navigation property access
+        // Create a selector that selects all columns only (not navigation properties)
         const allColumnsSelector = (e) => {
             const result = {};
             // Copy all column properties
             for (const colName of Object.keys(schema.columns)) {
                 result[colName] = e[colName];
             }
-            // Add navigation properties as enumerable getters
-            // The getter returns the actual navigation builder (CollectionQueryBuilder/ReferenceQueryBuilder)
-            // which allows chained selectors like .select(u => ({ posts: u.posts!.where(...) }))
-            // When the selection is analyzed, the builder is detected and handled appropriately
+            // Add navigation properties as non-enumerable getters
+            // This allows chained selectors like .select(u => ({ posts: u.posts!.where(...) }))
+            // but they won't be included in the default query output
             for (const relName of Object.keys(schema.relations)) {
                 Object.defineProperty(result, relName, {
                     get: () => e[relName],
-                    enumerable: true, // Enumerable so it's included in Object.entries
+                    enumerable: false, // Non-enumerable so it's NOT included in default selection
                     configurable: true,
                 });
             }
@@ -1411,20 +1454,37 @@ class DbEntityTable {
         const executor = this._getExecutor();
         const client = this._getClient();
         const qualifiedTableName = this._getQualifiedTableName();
-        // Get columns from first row
-        const referenceItem = data[0];
+        // Get columns from all rows - a column is included if ANY row has a non-undefined value for it
         const columnConfigs = [];
         for (const [propName, colBuilder] of Object.entries(schema.columns)) {
-            if (propName in referenceItem) {
-                const config = colBuilder.build();
-                if (!config.autoIncrement || overridingSystemValue) {
-                    columnConfigs.push({
-                        propName,
-                        dbName: config.name,
-                        mapper: config.mapper,
-                    });
+            const config = colBuilder.build();
+            // Skip auto-increment columns (unless overriding)
+            if (config.autoIncrement && !overridingSystemValue) {
+                continue;
+            }
+            // Check if any row has a defined (non-undefined) value for this column
+            const hasDefinedValue = data.some(record => {
+                const value = record[propName];
+                return value !== undefined;
+            });
+            // If column has a default and ALL rows have undefined, skip it (let DB use default)
+            // Otherwise, include it if at least one row has a defined value
+            if (!hasDefinedValue) {
+                // All rows have undefined - if there's a default, skip the column
+                if (config.default !== undefined || config.identity) {
+                    continue;
+                }
+                // No default, but column is present with undefined in data - include it (will become NULL)
+                const isPresentInAnyRow = data.some(record => propName in record);
+                if (!isPresentInAnyRow) {
+                    continue;
                 }
             }
+            columnConfigs.push({
+                propName,
+                dbName: config.name,
+                mapper: config.mapper,
+            });
         }
         // Build VALUES clauses
         const valuesClauses = [];
@@ -1461,7 +1521,7 @@ class DbEntityTable {
         if (!returningClause) {
             return undefined;
         }
-        return this.mapReturningResults(result.rows, returning);
+        return this.mapReturningResults(result.rows, returningClause.aliasToProperty);
     }
     /**
      * Upsert with advanced configuration
@@ -1669,7 +1729,7 @@ class DbEntityTable {
         if (!returningClause) {
             return undefined;
         }
-        return this.mapReturningResults(result.rows, returning);
+        return this.mapReturningResults(result.rows, returningClause.aliasToProperty);
     }
     /**
      * Map database column names back to property names
@@ -1752,8 +1812,10 @@ class DbEntityTable {
                 throw new Error('No valid columns to update');
             }
             // No WHERE clause - updates all records
-            // Build RETURNING clause
-            const returningClause = table.buildReturningClause(returning);
+            // Build RETURNING clause (not needed for count-only)
+            const returningClause = returning !== 'count'
+                ? table.buildReturningClause(returning)
+                : undefined;
             const qualifiedTableName = table._getQualifiedTableName();
             let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')}`;
             if (returningClause) {
@@ -1762,15 +1824,26 @@ class DbEntityTable {
             const result = executor
                 ? await executor.query(sql, values)
                 : await client.query(sql, values);
+            // Return affected count
+            if (returning === 'count') {
+                return result.rowCount ?? 0;
+            }
             if (!returningClause) {
                 return undefined;
             }
-            return table.mapReturningResults(result.rows, returning);
+            return table.mapReturningResults(result.rows, returningClause.aliasToProperty);
         };
         return {
             then(onfulfilled, onrejected) {
                 return executeUpdate(undefined).then(onfulfilled, onrejected);
             },
+            affectedCount() {
+                return {
+                    then(onfulfilled, onrejected) {
+                        return executeUpdate('count').then(onfulfilled, onrejected);
+                    }
+                };
+            },
             returning(selector) {
                 const returningConfig = selector ?? true;
                 return {
@@ -1971,7 +2044,7 @@ WHERE ${whereClause}`.trim();
         if (!returningClause) {
             return undefined;
         }
-        return this.mapReturningResults(result.rows, returning);
+        return this.mapReturningResults(result.rows, returningClause.aliasToProperty);
     }
     /**
      * Delete all records from the table
@@ -1991,11 +2064,14 @@ WHERE ${whereClause}`.trim();
         const baseSql = `DELETE FROM ${qualifiedTableName}`;
         const table = this;
         const executeDelete = async (returningConfig) => {
-            if (!returningConfig) {
+            if (!returningConfig || returningConfig === 'count') {
                 const sql = baseSql;
                 const result = executor
                     ? await executor.query(sql, [])
                     : await client.query(sql, []);
+                if (returningConfig === 'count') {
+                    return result.rowCount ?? 0;
+                }
                 return;
             }
             // Build RETURNING clause
@@ -2005,13 +2081,20 @@ WHERE ${whereClause}`.trim();
                 ? await executor.query(sql, [])
                 : await client.query(sql, []);
             if (returningClause && result.rows) {
-                return table.mapReturningResults(result.rows, returningConfig);
+                return table.mapReturningResults(result.rows, returningClause.aliasToProperty);
             }
         };
         const fluent = {
             then: (resolve, reject) => {
                 return executeDelete().then(resolve, reject);
             },
+            affectedCount: () => {
+                return {
+                    then: (resolve, reject) => {
+                        return executeDelete('count').then(resolve, reject);
+                    }
+                };
+            },
             returning: ((selector) => {
                 const returningConfig = selector ?? true;
                 return {
@@ -2090,14 +2173,20 @@ WHERE ${whereClause}`.trim();
         if (typeof selection === 'object' && selection !== null) {
             const columns = [];
             const sqlParts = [];
+            const aliasToProperty = new Map();
             for (const [alias, field] of Object.entries(selection)) {
                 if (field && typeof field === 'object' && '__dbColumnName' in field) {
                     const dbName = field.__dbColumnName;
+                    const propName = field.__fieldName; // Property name on entity
                     columns.push(alias);
                     sqlParts.push(`${prefix}"${dbName}" AS "${alias}"`);
+                    // Track alias -> property name mapping for mapper lookup
+                    if (propName) {
+                        aliasToProperty.set(alias, propName);
+                    }
                 }
             }
-            return { sql: sqlParts.join(', '), columns };
+            return { sql: sqlParts.join(', '), columns, aliasToProperty };
         }
         // Single field selection
         if (selection && typeof selection === 'object' && '__dbColumnName' in selection) {
@@ -2107,33 +2196,50 @@ WHERE ${whereClause}`.trim();
         return null;
     }
     /**
-     * Map row results based on returning config
+     * Map row results applying custom mappers
      * @internal
-     */
-    mapReturningResults(rows, returning) {
-        if (returning === true) {
-            // Full entity mapping
+     * @param rows - Raw database rows
+     * @param aliasToProperty - Optional mapping from result aliases to entity property names.
+     *                          If undefined, assumes full entity mapping (db column names -> property names)
+     */
+    mapReturningResults(rows, aliasToProperty) {
+        // If no alias mapping provided, use full entity mapping
+        // This handles the `returning === true` case where we want proper db column -> property name mapping
+        if (!aliasToProperty || aliasToProperty.size === 0) {
             return this.mapResultsToEntities(rows);
         }
-        // For selector functions, rows are already in the correct shape
-        // Just apply any type mappers needed
         const schema = this._getSchema();
         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(schema.columns).find(([propName, col]) => {
-                    const config = col.build();
-                    return propName === key || config.name === key;
-                });
-                if (colEntry) {
-                    const [propName, col] = colEntry;
-                    const config = col.build();
-                    // Apply fromDriver mapper if present
-                    mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
+                // Check if this key is an alias that maps to a property name
+                const propName = aliasToProperty.get(key);
+                if (propName) {
+                    // Found via alias mapping - use the property name to look up the column
+                    const colBuilder = schema.columns[propName];
+                    if (colBuilder) {
+                        const config = colBuilder.build();
+                        // Apply fromDriver mapper if present
+                        mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
+                    }
+                    else {
+                        mapped[key] = value;
+                    }
                 }
                 else {
-                    mapped[key] = value;
+                    // Try to find column by direct property name or db column name match
+                    const colEntry = Object.entries(schema.columns).find(([pName, col]) => {
+                        const config = col.build();
+                        return pName === key || config.name === key;
+                    });
+                    if (colEntry) {
+                        const config = colEntry[1].build();
+                        // Apply fromDriver mapper if present
+                        mapped[key] = config.mapper ? config.mapper.fromDriver(value) : value;
+                    }
+                    else {
+                        mapped[key] = value;
+                    }
                 }
             }
             return mapped;