linkgress-orm 0.1.17 → 0.1.19

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);
@@ -600,7 +607,12 @@ class TableAccessor {
             sql += '\n      OVERRIDING SYSTEM VALUE';
         }
         sql += `
-      VALUES ${valueClauses.join(', ')}
+      VALUES ${valueClauses.join(', ')}`;
+        // Add ON CONFLICT DO NOTHING if specified
+        if (insertConfig?.onConflictDoNothing) {
+            sql += '\n      ON CONFLICT DO NOTHING';
+        }
+        sql += `
       RETURNING ${returningColumns}
     `;
         const result = this.executor
@@ -663,65 +675,6 @@ class TableAccessor {
         }
         return builder.execute();
     }
-    /**
-     * Bulk insert multiple rows (simple version, kept for compatibility)
-     */
-    async insertMany(dataArray) {
-        if (dataArray.length === 0) {
-            return [];
-        }
-        // Extract all unique column names from all data objects
-        const columnSet = new Set();
-        for (const data of dataArray) {
-            for (const key of Object.keys(data)) {
-                const column = this.schema.columns[key];
-                if (column) {
-                    const config = column.build();
-                    if (!config.autoIncrement) {
-                        columnSet.add(key);
-                    }
-                }
-            }
-        }
-        const columns = Array.from(columnSet);
-        const values = [];
-        const valuePlaceholders = [];
-        let paramIndex = 1;
-        // Build placeholders for each row
-        for (const data of dataArray) {
-            const rowPlaceholders = [];
-            for (const key of columns) {
-                const value = data[key];
-                const column = this.schema.columns[key];
-                const config = column.build();
-                // Apply toDriver mapper if present
-                const mappedValue = config.mapper
-                    ? config.mapper.toDriver(value !== undefined ? value : null)
-                    : (value !== undefined ? value : null);
-                values.push(mappedValue);
-                rowPlaceholders.push(`$${paramIndex++}`);
-            }
-            valuePlaceholders.push(`(${rowPlaceholders.join(', ')})`);
-        }
-        const columnNames = columns.map(key => {
-            const column = this.schema.columns[key];
-            const config = column.build();
-            return `"${config.name}"`;
-        });
-        const returningColumns = Object.entries(this.schema.columns)
-            .map(([_, col]) => `"${col.build().name}"`)
-            .join(', ');
-        const qualifiedTableName = (0, sql_utils_1.getQualifiedTableName)(this.schema);
-        const sql = `
-      INSERT INTO ${qualifiedTableName} (${columnNames.join(', ')})
-      VALUES ${valuePlaceholders.join(', ')}
-      RETURNING ${returningColumns}
-    `;
-        const result = this.executor
-            ? await this.executor.query(sql, values)
-            : await this.client.query(sql, values);
-        return result.rows;
-    }
     /**
      * Insert with conflict resolution (upsert)
      */
@@ -846,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
@@ -875,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
@@ -984,6 +945,119 @@ class DbEntityTable {
     _getCollectionStrategy() {
         return this.context.queryOptions?.collectionStrategy;
     }
+    /**
+     * Get information about all columns in this table.
+     * This method returns metadata about database columns only, excluding navigation properties.
+     *
+     * @param options - Optional configuration
+     * @param options.includeNavigation - If false (default), only returns database columns.
+     *                                    Navigation properties are never included as they are not columns.
+     *
+     * @returns Array of column information objects
+     *
+     * @example
+     * ```typescript
+     * // Get all columns
+     * const columns = db.users.getColumns();
+     * // Returns: [
+     * //   { propertyName: 'id', columnName: 'id', type: 'integer', isPrimaryKey: true, ... },
+     * //   { propertyName: 'username', columnName: 'username', type: 'varchar', ... },
+     * //   { propertyName: 'email', columnName: 'email', type: 'text', ... },
+     * // ]
+     *
+     * // Get column names only
+     * const columnNames = db.users.getColumns().map(c => c.propertyName);
+     * // Returns: ['id', 'username', 'email', ...]
+     *
+     * // Get database column names
+     * const dbColumnNames = db.users.getColumns().map(c => c.columnName);
+     * // Returns: ['id', 'username', 'email', ...]
+     * ```
+     */
+    getColumns() {
+        const schema = this._getSchema();
+        const columns = [];
+        for (const [propName, colBuilder] of Object.entries(schema.columns)) {
+            const config = colBuilder.build();
+            columns.push({
+                propertyName: propName,
+                columnName: config.name,
+                type: config.type,
+                isPrimaryKey: config.primaryKey || false,
+                isAutoIncrement: config.autoIncrement || !!config.identity,
+                isNullable: config.nullable !== false,
+                isUnique: config.unique || false,
+                defaultValue: config.default,
+            });
+        }
+        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.
+     *
+     * @param options - Optional configuration
+     * @param options.excludeNavigation - If true (default), excludes navigation properties.
+     *                                    Set to false to include navigation properties.
+     *
+     * @returns Object with property names as keys and their DbColumn/navigation references as values
+     *
+     * @example
+     * ```typescript
+     * // Get all column properties (excludes navigation by default)
+     * const cols = db.users.props();
+     * // Use in select: db.users.select(u => ({ id: cols.id, name: cols.username }))
+     *
+     * // Include navigation properties
+     * const allProps = db.users.props({ excludeNavigation: false });
+     * ```
+     */
+    props(options) {
+        const schema = this._getSchema();
+        const excludeNav = options?.excludeNavigation !== false; // Default true
+        // Create a temporary QueryBuilder to reuse the createMockRow logic
+        const qb = new query_builder_1.QueryBuilder(schema, this._getClient(), undefined, undefined, undefined, undefined, this._getExecutor(), undefined, undefined, this._getCollectionStrategy(), this.context.schemaRegistry);
+        const mockRow = qb._createMockRow();
+        if (excludeNav) {
+            // Filter out navigation properties, keep only columns
+            const result = {};
+            for (const propName of Object.keys(schema.columns)) {
+                result[propName] = mockRow[propName];
+            }
+            return result;
+        }
+        return mockRow;
+    }
     /**
      * Get qualified table name with schema prefix if specified
      * @internal
@@ -1196,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,
                 });
             }
@@ -1226,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,
                 });
             }
@@ -1276,77 +1348,22 @@ class DbEntityTable {
      * ```
      */
     insert(data) {
-        const table = this;
-        const executeInsert = async (returning) => {
-            const schema = table._getSchema();
-            const executor = table._getExecutor();
-            const client = table._getClient();
-            // Build INSERT columns and values
-            const columns = [];
-            const values = [];
-            const placeholders = [];
-            let paramIndex = 1;
-            for (const [key, value] of Object.entries(data)) {
-                const column = schema.columns[key];
-                if (column) {
-                    const config = column.build();
-                    if (!config.autoIncrement) {
-                        columns.push(`"${config.name}"`);
-                        const mappedValue = config.mapper ? config.mapper.toDriver(value) : value;
-                        values.push(mappedValue);
-                        placeholders.push(`$${paramIndex++}`);
-                    }
-                }
-            }
-            // Build RETURNING clause
-            const returningClause = table.buildReturningClause(returning);
-            const qualifiedTableName = table._getQualifiedTableName();
-            let sql = `INSERT INTO ${qualifiedTableName} (${columns.join(', ')}) VALUES (${placeholders.join(', ')})`;
-            if (returningClause) {
-                sql += ` RETURNING ${returningClause.sql}`;
-            }
-            const result = executor
-                ? await executor.query(sql, values)
-                : await client.query(sql, values);
-            if (!returningClause) {
-                return undefined;
-            }
-            const mappedResults = table.mapReturningResults(result.rows, returning);
-            return mappedResults[0];
-        };
+        const bulkBuilder = this.insertBulk([data]);
         return {
             then(onfulfilled, onrejected) {
-                return executeInsert(undefined).then(onfulfilled, onrejected);
+                return bulkBuilder.then(onfulfilled, onrejected);
             },
             returning(selector) {
-                const returningConfig = selector ?? true;
+                const bulkReturning = selector ? bulkBuilder.returning(selector) : bulkBuilder.returning();
                 return {
                     then(onfulfilled, onrejected) {
-                        return executeInsert(returningConfig).then(onfulfilled, onrejected);
+                        // Unwrap array to single item
+                        return bulkReturning.then((results) => results?.[0], undefined).then(onfulfilled, onrejected);
                     }
                 };
             }
         };
     }
-    /**
-     * Insert multiple records
-     * Returns a fluent builder that can be awaited directly or chained with .returning()
-     *
-     * @example
-     * ```typescript
-     * // No returning (default) - returns void
-     * await db.users.insertMany([{ username: 'alice' }, { username: 'bob' }]);
-     *
-     * // With returning() - returns full entities
-     * const users = await db.users.insertMany([{ username: 'alice' }]).returning();
-     *
-     * // With returning(selector) - returns selected columns
-     * const results = await db.users.insertMany([{ username: 'alice' }]).returning(u => ({ id: u.id }));
-     * ```
-     */
-    insertMany(data) {
-        return this.insertBulk(data);
-    }
     /**
      * Upsert (insert or update on conflict)
      * Returns a fluent builder that can be awaited directly or chained with .returning()
@@ -1379,8 +1396,11 @@ class DbEntityTable {
      * // With returning(selector) - returns selected columns
      * const results = await db.users.insertBulk([{ username: 'alice' }]).returning(u => ({ id: u.id }));
      *
-     * // With options
+     * // With chunk size
      * await db.users.insertBulk([{ username: 'alice' }], { chunkSize: 100 });
+     *
+     * // Skip duplicates (ON CONFLICT DO NOTHING)
+     * await db.users.insertBulk([{ username: 'alice' }], { onConflictDoNothing: true });
      * ```
      */
     insertBulk(value, options) {
@@ -1403,13 +1423,13 @@ class DbEntityTable {
                 const allResults = [];
                 for (let i = 0; i < dataArray.length; i += chunkSize) {
                     const chunk = dataArray.slice(i, i + chunkSize);
-                    const chunkResults = await table.insertBulkSingle(chunk, returning, options?.overridingSystemValue);
+                    const chunkResults = await table.insertBulkSingle(chunk, returning, options?.overridingSystemValue, options?.onConflictDoNothing);
                     if (chunkResults)
                         allResults.push(...chunkResults);
                 }
                 return returning === undefined ? undefined : allResults;
             }
-            return table.insertBulkSingle(dataArray, returning, options?.overridingSystemValue);
+            return table.insertBulkSingle(dataArray, returning, options?.overridingSystemValue, options?.onConflictDoNothing);
         };
         return {
             then(onfulfilled, onrejected) {
@@ -1429,25 +1449,42 @@ class DbEntityTable {
      * Execute a single bulk insert batch
      * @internal
      */
-    async insertBulkSingle(data, returning, overridingSystemValue) {
+    async insertBulkSingle(data, returning, overridingSystemValue, onConflictDoNothing) {
         const schema = this._getSchema();
         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 = [];
@@ -1472,6 +1509,9 @@ class DbEntityTable {
             sql += ' OVERRIDING SYSTEM VALUE';
         }
         sql += ` VALUES ${valuesClauses.join(', ')}`;
+        if (onConflictDoNothing) {
+            sql += ' ON CONFLICT DO NOTHING';
+        }
         if (returningClause) {
             sql += ` RETURNING ${returningClause.sql}`;
         }
@@ -1772,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) {
@@ -1782,6 +1824,10 @@ 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;
             }
@@ -1791,6 +1837,13 @@ class DbEntityTable {
             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 {
@@ -2011,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
@@ -2032,6 +2088,13 @@ WHERE ${whereClause}`.trim();
             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 {