linkgress-orm 0.1.16 → 0.1.18

package/dist/entity/db-context.js

@@ -3,7 +3,6 @@ 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 entity_base_1 = require("./entity-base");
 const model_config_1 = require("./model-config");
-const conditions_1 = require("../query/conditions");
 const query_builder_1 = require("../query/query-builder");
 const db_schema_manager_1 = require("../migration/db-schema-manager");
 const sequence_builder_1 = require("../schema/sequence-builder");
@@ -601,7 +600,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
@@ -664,65 +668,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)
      */
@@ -856,10 +801,23 @@ class DataContext {
         return accessor;
     }
     /**
-     * Execute raw SQL
+     * Execute raw SQL query with optional type parameter for results
+     *
+     * @example
+     * ```typescript
+     * // Untyped query
+     * const result = await db.query('SELECT * FROM users');
+     *
+     * // Typed query - returns T[]
+     * const users = await db.query<{ id: number; name: string }>('SELECT id, name FROM users');
+     *
+     * // With parameters
+     * const user = await db.query<{ id: number }>('SELECT id FROM users WHERE name = $1', ['alice']);
+     * ```
      */
     async query(sql, params) {
-        return this.client.query(sql, params);
+        const result = await this.client.query(sql, params);
+        return result.rows;
     }
     /**
      * Execute in transaction
@@ -972,6 +930,89 @@ 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 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
@@ -1264,77 +1305,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()
@@ -1367,8 +1353,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) {
@@ -1391,13 +1380,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) {
@@ -1417,7 +1406,7 @@ 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();
@@ -1460,6 +1449,9 @@ class DbEntityTable {
             sql += ' OVERRIDING SYSTEM VALUE';
         }
         sql += ` VALUES ${valuesClauses.join(', ')}`;
+        if (onConflictDoNothing) {
+            sql += ' ON CONFLICT DO NOTHING';
+        }
         if (returningClause) {
             sql += ` RETURNING ${returningClause.sql}`;
         }
@@ -1730,23 +1722,15 @@ class DbEntityTable {
         return new EntityInsertBuilder(builder);
     }
     /**
-     * Update records matching condition
+     * Update all records in the table
      * Returns a fluent builder that can be awaited directly or chained with .returning()
      *
-     * @example
-     * ```typescript
-     * // No returning (default) - returns void
-     * await db.users.update({ age: 30 }, u => eq(u.id, 1));
-     *
-     * // With returning() - returns full entities
-     * const users = await db.users.update({ age: 30 }, u => eq(u.id, 1)).returning();
-     *
-     * // With returning(selector) - returns selected columns
-     * const results = await db.users.update({ age: 30 }, u => eq(u.id, 1))
-     *   .returning(u => ({ id: u.id, age: u.age }));
-     * ```
+     * Usage:
+     *   await db.users.update({ age: 30 }) // Update all
+     *   await db.users.where(u => eq(u.id, 1)).update({ age: 30 }) // Update with condition
+     *   const updated = await db.users.where(u => eq(u.id, 1)).update({ age: 30 }).returning()
      */
-    update(data, condition) {
+    update(data) {
         const table = this;
         const executeUpdate = async (returning) => {
             const schema = table._getSchema();
@@ -1767,16 +1751,11 @@ class DbEntityTable {
             if (setClauses.length === 0) {
                 throw new Error('No valid columns to update');
             }
-            // Build WHERE clause
-            const mockEntity = table.createMockEntity();
-            const whereCondition = condition(mockEntity);
-            const condBuilder = new conditions_1.ConditionBuilder();
-            const { sql: whereSql, params: whereParams } = condBuilder.build(whereCondition, paramIndex);
-            values.push(...whereParams);
+            // No WHERE clause - updates all records
             // Build RETURNING clause
             const returningClause = table.buildReturningClause(returning);
             const qualifiedTableName = table._getQualifiedTableName();
-            let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')} WHERE ${whereSql}`;
+            let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')}`;
             if (returningClause) {
                 sql += ` RETURNING ${returningClause.sql}`;
             }
@@ -1995,23 +1974,54 @@ WHERE ${whereClause}`.trim();
         return this.mapReturningResults(result.rows, returning);
     }
     /**
-     * Delete records matching condition
-     * Usage: db.users.delete(u => eq(u.id, 1))
+     * Delete all records from the table
+     * Returns a fluent builder that can be awaited directly or chained with .returning()
+     *
+     * Usage:
+     *   await db.users.delete() // Delete all
+     *   await db.users.where(u => eq(u.id, 1)).delete() // Delete with condition
+     *   const deleted = await db.users.where(u => eq(u.id, 1)).delete().returning()
      */
-    async delete(condition) {
+    delete() {
         const schema = this._getSchema();
         const executor = this._getExecutor();
         const client = this._getClient();
-        // Build WHERE clause
-        const mockEntity = this.createMockEntity();
-        const whereCondition = condition(mockEntity);
-        const condBuilder = new conditions_1.ConditionBuilder();
-        const { sql: whereSql, params: whereParams } = condBuilder.build(whereCondition, 1);
         const qualifiedTableName = this._getQualifiedTableName();
-        const sql = `DELETE FROM ${qualifiedTableName} WHERE ${whereSql}`;
-        const result = executor
-            ? await executor.query(sql, whereParams)
-            : await client.query(sql, whereParams);
+        // No WHERE condition - deletes all records
+        const baseSql = `DELETE FROM ${qualifiedTableName}`;
+        const table = this;
+        const executeDelete = async (returningConfig) => {
+            if (!returningConfig) {
+                const sql = baseSql;
+                const result = executor
+                    ? await executor.query(sql, [])
+                    : await client.query(sql, []);
+                return;
+            }
+            // Build RETURNING clause
+            const returningClause = table.buildReturningClause(returningConfig);
+            const sql = returningClause ? `${baseSql} RETURNING ${returningClause.sql}` : baseSql;
+            const result = executor
+                ? await executor.query(sql, [])
+                : await client.query(sql, []);
+            if (returningClause && result.rows) {
+                return table.mapReturningResults(result.rows, returningConfig);
+            }
+        };
+        const fluent = {
+            then: (resolve, reject) => {
+                return executeDelete().then(resolve, reject);
+            },
+            returning: ((selector) => {
+                const returningConfig = selector ?? true;
+                return {
+                    then: (resolve, reject) => {
+                        return executeDelete(returningConfig).then(resolve, reject);
+                    }
+                };
+            })
+        };
+        return fluent;
     }
     /**
      * Create a mock entity for type inference in lambdas