linkgress-orm 0.0.1

package/dist/entity/db-context.js

@@ -0,0 +1,1463 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseContext = exports.DbEntityTable = exports.EntityInsertBuilder = exports.DataContext = exports.TableAccessor = exports.InsertBuilder = exports.QueryExecutor = 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");
+/**
+ * Query executor with optional logging
+ */
+class QueryExecutor {
+    constructor(client, options = {}) {
+        this.client = client;
+        this.options = options;
+    }
+    async query(sql, params) {
+        const logger = this.options.logger || console.log;
+        const startTime = this.options.logExecutionTime ? performance.now() : 0;
+        if (this.options.logQueries) {
+            logger(`\n[SQL Query]`);
+            logger(sql.trim());
+            if (this.options.logParameters && params && params.length > 0) {
+                logger(`[Parameters] ${JSON.stringify(params)}`);
+            }
+        }
+        try {
+            const result = await this.client.query(sql, params);
+            if (this.options.logExecutionTime) {
+                const duration = (performance.now() - startTime).toFixed(2);
+                logger(`[Execution Time] ${duration}ms`);
+            }
+            return result;
+        }
+        catch (error) {
+            if (this.options.logQueries) {
+                logger(`[SQL Error] ${error instanceof Error ? error.message : String(error)}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Execute a multi-statement query using the simple protocol (no parameters)
+     * Only available for clients that support it (e.g., PostgresClient)
+     */
+    async querySimple(sql) {
+        const logger = this.options.logger || console.log;
+        const startTime = this.options.logExecutionTime ? performance.now() : 0;
+        if (this.options.logQueries) {
+            logger(`\n[SQL Query - Multi-Statement]`);
+            logger(sql.trim());
+        }
+        try {
+            // Check if client has querySimple method
+            if ('querySimple' in this.client && typeof this.client.querySimple === 'function') {
+                const result = await this.client.querySimple(sql);
+                if (this.options.logExecutionTime) {
+                    const duration = (performance.now() - startTime).toFixed(2);
+                    logger(`[Execution Time] ${duration}ms`);
+                }
+                return result;
+            }
+            else {
+                // Fallback to regular query
+                const result = await this.client.query(sql, []);
+                if (this.options.logExecutionTime) {
+                    const duration = (performance.now() - startTime).toFixed(2);
+                    logger(`[Execution Time] ${duration}ms`);
+                }
+                return result;
+            }
+        }
+        catch (error) {
+            if (this.options.logQueries) {
+                logger(`[SQL Error] ${error instanceof Error ? error.message : String(error)}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Execute a multi-statement query and return ALL result sets
+     * Only available for PostgresClient
+     */
+    async querySimpleMulti(sql) {
+        const logger = this.options.logger || console.log;
+        const startTime = this.options.logExecutionTime ? performance.now() : 0;
+        if (this.options.logQueries) {
+            logger(`\n[SQL Query - Fully Optimized Multi-Statement]`);
+            logger(sql.trim());
+        }
+        try {
+            // Check if client has querySimpleMulti method
+            if ('querySimpleMulti' in this.client && typeof this.client.querySimpleMulti === 'function') {
+                const results = await this.client.querySimpleMulti(sql);
+                if (this.options.logExecutionTime) {
+                    const duration = (performance.now() - startTime).toFixed(2);
+                    logger(`[Execution Time] ${duration}ms`);
+                }
+                return results;
+            }
+            else {
+                throw new Error('querySimpleMulti not supported by this client');
+            }
+        }
+        catch (error) {
+            if (this.options.logQueries) {
+                logger(`[SQL Error] ${error instanceof Error ? error.message : String(error)}`);
+            }
+            throw error;
+        }
+    }
+}
+exports.QueryExecutor = QueryExecutor;
+/**
+ * Insert builder for upsert operations
+ */
+class InsertBuilder {
+    constructor(schema, client, executor) {
+        this.schema = schema;
+        this.client = client;
+        this.executor = executor;
+        this.dataArray = [];
+        this.conflictAction = 'nothing';
+        this.overridingSystemValue = false;
+    }
+    /**
+     * Get qualified table name with schema prefix if specified
+     */
+    getQualifiedTableName() {
+        return this.schema.schema
+            ? `"${this.schema.schema}"."${this.schema.name}"`
+            : `"${this.schema.name}"`;
+    }
+    /**
+     * Set the values to insert (single row or multiple rows)
+     */
+    values(data) {
+        this.dataArray = Array.isArray(data) ? data : [data];
+        return this;
+    }
+    /**
+     * Specify conflict target (columns or constraint name)
+     */
+    onConflict(target) {
+        if (Array.isArray(target)) {
+            this.conflictTarget = { columns: target };
+        }
+        else {
+            this.conflictTarget = target;
+        }
+        return this;
+    }
+    /**
+     * Do nothing on conflict
+     */
+    doNothing() {
+        this.conflictAction = 'nothing';
+        return this;
+    }
+    /**
+     * Update on conflict (upsert)
+     */
+    doUpdate(options) {
+        this.conflictAction = 'update';
+        if (options?.set) {
+            this.updateColumns = Object.keys(options.set);
+        }
+        if (options?.updateColumns) {
+            this.updateColumns = options.updateColumns;
+        }
+        if (options?.updateColumnFilter) {
+            this.updateColumnFilter = options.updateColumnFilter;
+        }
+        if (options?.where) {
+            this.setWhereClause = options.where;
+        }
+        return this;
+    }
+    /**
+     * Set target WHERE clause for ON CONFLICT
+     */
+    targetWhere(where) {
+        this.targetWhereClause = where;
+        return this;
+    }
+    /**
+     * Enable OVERRIDING SYSTEM VALUE
+     */
+    setOverridingSystemValue(value = true) {
+        this.overridingSystemValue = value;
+        return this;
+    }
+    /**
+     * Execute the insert/upsert
+     */
+    async execute() {
+        if (this.dataArray.length === 0) {
+            return [];
+        }
+        // Extract all unique column names from all data objects
+        const columnSet = new Set();
+        for (const data of this.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 this.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 = this.getQualifiedTableName();
+        let sql = `INSERT INTO ${qualifiedTableName} (${columnNames.join(', ')})`;
+        // Add OVERRIDING SYSTEM VALUE if specified
+        if (this.overridingSystemValue) {
+            sql += '\n      OVERRIDING SYSTEM VALUE';
+        }
+        sql += `\n      VALUES ${valuePlaceholders.join(', ')}`;
+        // Add conflict handling
+        if (this.conflictTarget || this.conflictAction) {
+            sql += '\n      ON CONFLICT';
+            if (this.conflictTarget) {
+                if (this.conflictTarget.columns) {
+                    const conflictCols = this.conflictTarget.columns.map(c => `"${c}"`).join(', ');
+                    sql += ` (${conflictCols})`;
+                }
+                else if (this.conflictTarget.constraint) {
+                    sql += ` ON CONSTRAINT ${this.conflictTarget.constraint}`;
+                }
+            }
+            // Add target WHERE clause
+            if (this.targetWhereClause) {
+                sql += ` WHERE ${this.targetWhereClause}`;
+            }
+            if (this.conflictAction === 'nothing') {
+                sql += ' DO NOTHING';
+            }
+            else if (this.conflictAction === 'update') {
+                sql += ' DO UPDATE SET ';
+                // Determine which columns to update
+                let columnsToUpdate;
+                if (this.updateColumns) {
+                    // Use explicitly specified columns
+                    columnsToUpdate = this.updateColumns;
+                }
+                else if (this.updateColumnFilter) {
+                    // Use filter function
+                    columnsToUpdate = columns.filter(this.updateColumnFilter);
+                }
+                else {
+                    // Update all non-primary key columns
+                    columnsToUpdate = columns.filter(key => {
+                        const column = this.schema.columns[key];
+                        const config = column.build();
+                        return !config.primaryKey;
+                    });
+                }
+                const updateParts = columnsToUpdate.map(col => {
+                    const column = this.schema.columns[col];
+                    const config = column.build();
+                    return `"${config.name}" = EXCLUDED."${config.name}"`;
+                });
+                sql += updateParts.join(', ');
+                if (this.setWhereClause) {
+                    sql += ` WHERE ${this.setWhereClause}`;
+                }
+            }
+        }
+        sql += `\n      RETURNING ${returningColumns}`;
+        const result = this.executor
+            ? await this.executor.query(sql, values)
+            : await this.client.query(sql, values);
+        return result.rows;
+    }
+}
+exports.InsertBuilder = InsertBuilder;
+/**
+ * Table accessor with query methods
+ */
+class TableAccessor {
+    constructor(tableBuilder, client, schemaRegistry, executor, collectionStrategy) {
+        this.tableBuilder = tableBuilder;
+        this.client = client;
+        this.schemaRegistry = schemaRegistry;
+        this.executor = executor;
+        this.collectionStrategy = collectionStrategy;
+        this.schema = tableBuilder.build();
+    }
+    /**
+     * Configure query options for the current query chain
+     * Returns a new TableAccessor instance with the specified options
+     *
+     * @example
+     * ```typescript
+     * const results = await db.users
+     *   .withQueryOptions({ logQueries: true, collectionStrategy: 'temptable' })
+     *   .select(u => ({ id: u.id, name: u.username }))
+     *   .toList();
+     * ```
+     */
+    withQueryOptions(options) {
+        // Merge options with existing collectionStrategy
+        const mergedStrategy = options.collectionStrategy ?? this.collectionStrategy;
+        // Create new executor if logging options are provided
+        let newExecutor = this.executor;
+        if (options.logQueries || options.logExecutionTime) {
+            newExecutor = new QueryExecutor(this.client, {
+                ...options,
+                collectionStrategy: mergedStrategy,
+            });
+        }
+        // Return new instance with updated options
+        return new TableAccessor(this.tableBuilder, this.client, this.schemaRegistry, newExecutor, mergedStrategy);
+    }
+    /**
+     * Start a select query with automatic type inference
+     */
+    select(selector) {
+        return new query_builder_1.SelectQueryBuilder(this.schema, this.client, selector, undefined, undefined, undefined, undefined, this.executor, undefined, undefined, undefined, this.schemaRegistry, undefined, this.collectionStrategy);
+    }
+    /**
+     * Add WHERE condition before select
+     */
+    where(condition) {
+        const qb = new query_builder_1.QueryBuilder(this.schema, this.client, undefined, undefined, undefined, undefined, this.executor, undefined, undefined, this.collectionStrategy);
+        return qb.where(condition);
+    }
+    /**
+     * Left join with another table and selector
+     */
+    leftJoin(rightTable, condition, selector, alias) {
+        const qb = new query_builder_1.QueryBuilder(this.schema, this.client, undefined, undefined, undefined, undefined, this.executor, undefined, undefined, this.collectionStrategy);
+        return qb.leftJoin(rightTable, condition, selector, alias);
+    }
+    /**
+     * Inner join with another table or subquery and selector
+     */
+    innerJoin(rightTable, condition, selector, alias) {
+        const qb = new query_builder_1.QueryBuilder(this.schema, this.client, undefined, undefined, undefined, undefined, this.executor, undefined, undefined, this.collectionStrategy);
+        return qb.innerJoin(rightTable, condition, selector, alias);
+    }
+    /**
+     * Get table schema (internal use for joins)
+     */
+    _getSchema() {
+        return this.schema;
+    }
+    /**
+     * Get table schema
+     */
+    getSchema() {
+        return this.schema;
+    }
+    /**
+     * Get table name
+     */
+    getTableName() {
+        return this.schema.name;
+    }
+    /**
+     * Get qualified table name with schema prefix if specified
+     */
+    getQualifiedTableName() {
+        return this.schema.schema
+            ? `"${this.schema.schema}"."${this.schema.name}"`
+            : `"${this.schema.name}"`;
+    }
+    /**
+     * Insert a row
+     */
+    async insert(data) {
+        const columns = [];
+        const values = [];
+        const placeholders = [];
+        let paramIndex = 1;
+        for (const [key, value] of Object.entries(data)) {
+            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++}`);
+                }
+            }
+        }
+        const returningColumns = Object.entries(this.schema.columns)
+            .map(([_, col]) => `"${col.build().name}"`)
+            .join(', ');
+        const qualifiedTableName = this.getQualifiedTableName();
+        const sql = `
+      INSERT INTO ${qualifiedTableName} (${columns.join(', ')})
+      VALUES (${placeholders.join(', ')})
+      RETURNING ${returningColumns}
+    `;
+        const result = this.executor
+            ? await this.executor.query(sql, values)
+            : await this.client.query(sql, values);
+        return result.rows[0];
+    }
+    /**
+     * Bulk insert with advanced configuration
+     */
+    async insertBulk(value, insertConfig) {
+        const dataArray = Array.isArray(value) ? value : [value];
+        if (dataArray.length === 0) {
+            return [];
+        }
+        // Calculate chunk size based on max rows per batch
+        let chunkSize = insertConfig?.chunkSize;
+        if (chunkSize == null && dataArray.length > 0) {
+            const POSTGRES_MAX_PARAMS = 65535; // PostgreSQL parameter limit
+            const columnCount = Object.keys(dataArray[0]).length;
+            const maxRowsPerBatch = Math.floor(POSTGRES_MAX_PARAMS / columnCount);
+            chunkSize = Math.floor(maxRowsPerBatch * 0.6); // Use 60% of max to be safe
+        }
+        // Check if we need to chunk
+        if (chunkSize && dataArray.length > chunkSize) {
+            const results = [];
+            for (let i = 0; i < dataArray.length; i += chunkSize) {
+                const chunk = dataArray.slice(i, i + chunkSize);
+                const chunkResults = await this.insertBulkSingle(chunk, insertConfig);
+                results.push(...chunkResults);
+            }
+            return results;
+        }
+        else {
+            return this.insertBulkSingle(dataArray, insertConfig);
+        }
+    }
+    /**
+     * Insert a single chunk (internal method)
+     */
+    async insertBulkSingle(dataArray, insertConfig) {
+        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 || insertConfig?.overridingSystemValue) {
+                        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 = this.getQualifiedTableName();
+        let sql = `INSERT INTO ${qualifiedTableName} (${columnNames.join(', ')})`;
+        if (insertConfig?.overridingSystemValue) {
+            sql += '\n      OVERRIDING SYSTEM VALUE';
+        }
+        sql += `\n      VALUES ${valuePlaceholders.join(', ')}
+      RETURNING ${returningColumns}`;
+        const result = this.executor
+            ? await this.executor.query(sql, values)
+            : await this.client.query(sql, values);
+        return result.rows;
+    }
+    /**
+     * Upsert with advanced configuration
+     */
+    async upsertBulk(values, config) {
+        if (values.length === 0) {
+            return [];
+        }
+        const referenceItem = config?.referenceItem || values[0];
+        // Determine primary keys
+        let primaryKeys = [];
+        if (config?.primaryKey) {
+            primaryKeys = Array.isArray(config.primaryKey) ? config.primaryKey : [config.primaryKey];
+        }
+        else {
+            // Auto-detect from schema
+            for (const [key, colBuilder] of Object.entries(this.schema.columns)) {
+                const colConfig = colBuilder.build();
+                if (colConfig.primaryKey) {
+                    primaryKeys.push(key);
+                }
+            }
+        }
+        // Auto-detect overridingSystemValue
+        let overridingSystemValue = config?.overridingSystemValue;
+        if (overridingSystemValue == null) {
+            for (const key of Object.keys(referenceItem)) {
+                const column = this.schema.columns[key];
+                if (column) {
+                    const colConfig = column.build();
+                    if (colConfig.primaryKey && colConfig.autoIncrement) {
+                        overridingSystemValue = true;
+                        break;
+                    }
+                }
+            }
+        }
+        // Determine which columns to update
+        let updateColumnFilter = config?.updateColumnFilter;
+        if (updateColumnFilter == null && config?.updateColumns) {
+            const updateColSet = new Set(config.updateColumns);
+            updateColumnFilter = (colId) => updateColSet.has(colId);
+        }
+        if (updateColumnFilter == null) {
+            updateColumnFilter = (colId) => !primaryKeys.includes(colId);
+        }
+        // Calculate chunk size based on max rows per batch
+        let chunkSize = config?.chunkSize;
+        if (chunkSize == null && values.length > 0) {
+            const POSTGRES_MAX_PARAMS = 65535;
+            const columnCount = Object.keys(values[0]).length;
+            const maxRowsPerBatch = Math.floor(POSTGRES_MAX_PARAMS / columnCount);
+            chunkSize = Math.floor(maxRowsPerBatch * 0.6); // Use 60% of max to be safe
+        }
+        // Check if we need to chunk
+        if (chunkSize && values.length > chunkSize) {
+            const results = [];
+            for (let i = 0; i < values.length; i += chunkSize) {
+                const chunk = values.slice(i, i + chunkSize);
+                const chunkResults = await this.upsertBulkSingle(chunk, primaryKeys, updateColumnFilter, overridingSystemValue || false, config?.targetWhere, config?.setWhere);
+                results.push(...chunkResults);
+            }
+            return results;
+        }
+        else {
+            return this.upsertBulkSingle(values, primaryKeys, updateColumnFilter, overridingSystemValue || false, config?.targetWhere, config?.setWhere);
+        }
+    }
+    /**
+     * Upsert a single chunk (internal method)
+     */
+    async upsertBulkSingle(values, primaryKeys, updateColumnFilter, overridingSystemValue, targetWhere, setWhere) {
+        const builder = new InsertBuilder(this.schema, this.client, this.executor);
+        builder.values(values);
+        builder.setOverridingSystemValue(overridingSystemValue);
+        builder.onConflict({ columns: primaryKeys });
+        builder.doUpdate({ updateColumnFilter, where: setWhere });
+        if (targetWhere) {
+            builder.targetWhere(targetWhere);
+        }
+        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 = this.getQualifiedTableName();
+        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)
+     */
+    onConflictDoNothing() {
+        return new InsertBuilder(this.schema, this.client, this.executor);
+    }
+    /**
+     * Insert with conflict resolution (upsert) - start building the upsert query
+     */
+    values(data) {
+        const builder = new InsertBuilder(this.schema, this.client, this.executor);
+        return builder.values(data);
+    }
+    /**
+     * Update rows
+     */
+    async update(id, data) {
+        const setClauses = [];
+        const values = [];
+        let paramIndex = 1;
+        // Find primary key
+        let pkColumnName;
+        for (const [key, col] of Object.entries(this.schema.columns)) {
+            const config = col.build();
+            if (config.primaryKey) {
+                pkColumnName = config.name;
+                break;
+            }
+        }
+        if (!pkColumnName) {
+            throw new Error(`Table ${this.schema.name} has no primary key`);
+        }
+        for (const [key, value] of Object.entries(data)) {
+            const column = this.schema.columns[key];
+            if (column) {
+                const config = column.build();
+                if (!config.primaryKey) {
+                    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) {
+            return null;
+        }
+        values.push(id);
+        const returningColumns = Object.entries(this.schema.columns)
+            .map(([_, col]) => `"${col.build().name}"`)
+            .join(', ');
+        const qualifiedTableName = this.getQualifiedTableName();
+        const sql = `
+      UPDATE ${qualifiedTableName}
+      SET ${setClauses.join(', ')}
+      WHERE "${pkColumnName}" = $${paramIndex}
+      RETURNING ${returningColumns}
+    `;
+        const result = this.executor
+            ? await this.executor.query(sql, values)
+            : await this.client.query(sql, values);
+        return result.rows.length > 0 ? result.rows[0] : null;
+    }
+    /**
+     * Delete a row by id
+     */
+    async delete(id) {
+        // Find primary key
+        let pkColumnName;
+        for (const [key, col] of Object.entries(this.schema.columns)) {
+            const config = col.build();
+            if (config.primaryKey) {
+                pkColumnName = config.name;
+                break;
+            }
+        }
+        if (!pkColumnName) {
+            throw new Error(`Table ${this.schema.name} has no primary key`);
+        }
+        const qualifiedTableName = this.getQualifiedTableName();
+        const sql = `DELETE FROM ${qualifiedTableName} WHERE "${pkColumnName}" = $1`;
+        const result = this.executor
+            ? await this.executor.query(sql, [id])
+            : await this.client.query(sql, [id]);
+        return result.rowCount !== null && result.rowCount > 0;
+    }
+}
+exports.TableAccessor = TableAccessor;
+/**
+ * DataContext - main entry point for database operations
+ */
+class DataContext {
+    constructor(client, schema, queryOptions) {
+        this.schemaRegistry = new Map();
+        this.tableAccessors = new Map();
+        this.client = client;
+        this.queryOptions = queryOptions;
+        // Create executor if logging is enabled
+        if (queryOptions?.logQueries || queryOptions?.logExecutionTime) {
+            this.executor = new QueryExecutor(client, queryOptions);
+        }
+        this.initializeSchema(schema);
+    }
+    /**
+     * Initialize schema and create table accessors
+     */
+    initializeSchema(schema) {
+        for (const [key, tableBuilder] of Object.entries(schema)) {
+            const tableSchema = tableBuilder.build();
+            this.schemaRegistry.set(tableSchema.name, tableSchema);
+            const accessor = new TableAccessor(tableBuilder, this.client, this.schemaRegistry, this.executor, this.queryOptions?.collectionStrategy);
+            this.tableAccessors.set(key, accessor);
+            // Attach to context (skip if property already has a getter on prototype chain)
+            const descriptor = Object.getOwnPropertyDescriptor(this, key) ||
+                Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this), key);
+            if (!descriptor || !descriptor.get) {
+                this[key] = accessor;
+            }
+        }
+    }
+    /**
+     * Get table accessor by name
+     */
+    getTable(name) {
+        const accessor = this.tableAccessors.get(name);
+        if (!accessor) {
+            throw new Error(`Table ${String(name)} not found in schema`);
+        }
+        return accessor;
+    }
+    /**
+     * Execute raw SQL
+     */
+    async query(sql, params) {
+        return this.client.query(sql, params);
+    }
+    /**
+     * Execute in transaction
+     */
+    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();
+        }
+    }
+    /**
+     * Get schema manager for create/drop operations and automatic migrations
+     */
+    getSchemaManager() {
+        return new db_schema_manager_1.DbSchemaManager(this.client, this.schemaRegistry, { logQueries: this.queryOptions?.logQueries });
+    }
+    /**
+     * Close database connection
+     */
+    async dispose() {
+        await this.client.end();
+    }
+}
+exports.DataContext = DataContext;
+/**
+ * DbEntity insert builder for upsert operations with proper typing
+ */
+class EntityInsertBuilder {
+    constructor(builder) {
+        this.builder = builder;
+    }
+    /**
+     * Specify conflict target (columns or constraint name)
+     */
+    onConflict(target) {
+        this.builder.onConflict(target);
+        return this;
+    }
+    /**
+     * Do nothing on conflict
+     */
+    doNothing() {
+        this.builder.doNothing();
+        return this;
+    }
+    /**
+     * Update on conflict (upsert)
+     */
+    doUpdate(options) {
+        this.builder.doUpdate(options);
+        return this;
+    }
+    /**
+     * Execute the insert/upsert
+     */
+    async execute() {
+        return this.builder.execute();
+    }
+}
+exports.EntityInsertBuilder = EntityInsertBuilder;
+/**
+ * Table accessor with entity typing
+ */
+class DbEntityTable {
+    constructor(context, tableName, tableBuilder) {
+        this.context = context;
+        this.tableName = tableName;
+        this.tableBuilder = tableBuilder;
+    }
+    /**
+     * Get the table schema for this entity
+     * @internal
+     */
+    _getSchema() {
+        const schemaRegistry = this.context.schemaRegistry;
+        const schema = schemaRegistry.get(this.tableName);
+        if (!schema) {
+            throw new Error(`Schema not found for table ${this.tableName}`);
+        }
+        return schema;
+    }
+    /**
+     * Get the database client
+     * @internal
+     */
+    _getClient() {
+        return this.context.client;
+    }
+    /**
+     * Get the query executor for logging
+     * @internal
+     */
+    _getExecutor() {
+        return this.context.executor;
+    }
+    /**
+     * Get the collection strategy
+     * @internal
+     */
+    _getCollectionStrategy() {
+        return this.context.queryOptions?.collectionStrategy;
+    }
+    /**
+     * Get qualified table name with schema prefix if specified
+     * @internal
+     */
+    _getQualifiedTableName() {
+        const schema = this._getSchema();
+        return schema.schema
+            ? `"${schema.schema}"."${schema.name}"`
+            : `"${schema.name}"`;
+    }
+    /**
+     * Configure query options for the current query chain
+     * Returns a new DbEntityTable instance with a modified context that has the specified options
+     *
+     * @example
+     * ```typescript
+     * const results = await db.users
+     *   .withQueryOptions({ logQueries: true, collectionStrategy: 'temptable' })
+     *   .select(u => ({ id: u.id, name: u.username }))
+     *   .toList();
+     * ```
+     */
+    withQueryOptions(options) {
+        // Create a proxy context with modified options
+        const originalContext = this.context;
+        const originalOptions = originalContext.queryOptions || {};
+        const tableName = this.tableName;
+        // Merge options
+        const mergedOptions = { ...originalOptions, ...options };
+        // Create new executor if logging options are provided
+        let newExecutor = originalContext.executor;
+        if (mergedOptions.logQueries || mergedOptions.logExecutionTime) {
+            newExecutor = new QueryExecutor(originalContext.client, mergedOptions);
+        }
+        // Create a proxy context that overrides queryOptions, executor, and getTable
+        const proxyContext = new Proxy(originalContext, {
+            get(target, prop) {
+                if (prop === 'queryOptions') {
+                    return mergedOptions;
+                }
+                if (prop === 'executor') {
+                    return newExecutor;
+                }
+                if (prop === 'getTable') {
+                    return (name) => {
+                        // Get the original TableAccessor
+                        const originalAccessor = target.tableAccessors.get(name);
+                        if (!originalAccessor) {
+                            return target.getTable(name);
+                        }
+                        // If requesting this table, return a TableAccessor with updated options
+                        if (name === tableName) {
+                            const schemaRegistry = target.schemaRegistry;
+                            const client = target.client;
+                            const originalTableBuilder = originalAccessor.tableBuilder;
+                            return new TableAccessor(originalTableBuilder, client, schemaRegistry, newExecutor, mergedOptions.collectionStrategy);
+                        }
+                        // Otherwise return the original table
+                        return originalAccessor;
+                    };
+                }
+                return target[prop];
+            }
+        });
+        // Return new instance with proxy context
+        return new DbEntityTable(proxyContext, this.tableName, this.tableBuilder);
+    }
+    /**
+     * Select all records - returns full entities with unwrapped DbColumns
+     */
+    async toList() {
+        const queryBuilder = this.context.getTable(this.tableName);
+        const schema = this._getSchema();
+        // Build SELECT with all columns
+        const columns = Object.entries(schema.columns)
+            .map(([_, col]) => `"${col.build().name}"`)
+            .join(', ');
+        const qualifiedTableName = this._getQualifiedTableName();
+        const sql = `SELECT ${columns} FROM ${qualifiedTableName}`;
+        const executor = this._getExecutor();
+        const client = this._getClient();
+        const result = executor
+            ? await executor.query(sql, [])
+            : await client.query(sql, []);
+        return this.mapResultsToEntities(result.rows);
+    }
+    /**
+     * Count all records
+     */
+    async count() {
+        const schema = this._getSchema();
+        const qualifiedTableName = this._getQualifiedTableName();
+        const sql = `SELECT COUNT(*) as count FROM ${qualifiedTableName}`;
+        const executor = this._getExecutor();
+        const client = this._getClient();
+        const result = executor
+            ? await executor.query(sql, [])
+            : await client.query(sql, []);
+        return parseInt(result.rows[0].count);
+    }
+    orderBy(selector) {
+        const schema = this._getSchema();
+        const allColumnsSelector = (e) => {
+            const result = {};
+            for (const colName of Object.keys(schema.columns)) {
+                result[colName] = e[colName];
+            }
+            return result;
+        };
+        const qb = this.context.getTable(this.tableName).select(allColumnsSelector);
+        return qb.orderBy(selector);
+    }
+    /**
+     * Limit results
+     */
+    limit(count) {
+        const schema = this._getSchema();
+        const allColumnsSelector = (e) => {
+            const result = {};
+            for (const colName of Object.keys(schema.columns)) {
+                result[colName] = e[colName];
+            }
+            return result;
+        };
+        const qb = this.context.getTable(this.tableName).select(allColumnsSelector);
+        return qb.limit(count);
+    }
+    /**
+     * Offset results
+     */
+    offset(count) {
+        const schema = this._getSchema();
+        const allColumnsSelector = (e) => {
+            const result = {};
+            for (const colName of Object.keys(schema.columns)) {
+                result[colName] = e[colName];
+            }
+            return result;
+        };
+        const qb = this.context.getTable(this.tableName).select(allColumnsSelector);
+        return qb.offset(count);
+    }
+    /**
+     * Select query
+     */
+    select(selector) {
+        const queryBuilder = this.context.getTable(this.tableName).select(selector);
+        return queryBuilder;
+    }
+    /**
+     * Select distinct
+     */
+    selectDistinct(selector) {
+        const queryBuilder = this.context.getTable(this.tableName);
+        // First select, then call selectDistinct to get a new builder with isDistinct=true
+        const selectBuilder = queryBuilder.select(selector);
+        const distinctBuilder = selectBuilder.selectDistinct((x) => x);
+        return distinctBuilder;
+    }
+    /**
+     * Where query - returns all columns by default
+     */
+    where(condition) {
+        const schema = this._getSchema();
+        // Create a selector that selects all columns with navigation property access
+        const allColumnsSelector = (e) => {
+            const result = {};
+            // Copy all column properties
+            for (const colName of Object.keys(schema.columns)) {
+                result[colName] = e[colName];
+            }
+            // Add navigation properties
+            for (const relName of Object.keys(schema.relations)) {
+                const relConfig = schema.relations[relName];
+                if (relConfig.type === 'many') {
+                    // For collections, use empty array placeholder
+                    // (prevents CollectionQueryBuilder evaluation)
+                    result[relName] = [];
+                }
+                else {
+                    // For references, copy the ReferenceQueryBuilder mock
+                    // This allows accessing fields like o.user!.username in chained selectors
+                    result[relName] = e[relName];
+                }
+            }
+            return result;
+        };
+        const queryBuilder = this.context.getTable(this.tableName)
+            .where(condition)
+            .select(allColumnsSelector);
+        return queryBuilder;
+    }
+    /**
+     * Left join with another table or subquery and selector
+     */
+    leftJoin(rightTable, condition, selector, alias) {
+        const queryBuilder = this.context.getTable(this.tableName).leftJoin(rightTable, condition, selector, alias);
+        return queryBuilder;
+    }
+    /**
+     * Inner join with another table or subquery and selector
+     */
+    innerJoin(rightTable, condition, selector, alias) {
+        const queryBuilder = this.context.getTable(this.tableName).innerJoin(rightTable, condition, selector, alias);
+        return queryBuilder;
+    }
+    /**
+     * Insert - accepts only DbColumn properties (excludes navigation properties)
+     */
+    async insert(data) {
+        const result = await this.context.getTable(this.tableName).insert(data);
+        return this.mapResultToEntity(result);
+    }
+    /**
+     * Insert multiple records
+     */
+    async insertMany(data) {
+        return this.insertBulk(data);
+    }
+    /**
+     * Upsert (insert or update on conflict)
+     */
+    async upsert(data, config) {
+        return this.upsertBulk(data, config);
+    }
+    /**
+     * Bulk insert with advanced configuration
+     * Supports automatic chunking for large datasets
+     */
+    async insertBulk(value, insertConfig) {
+        const results = await this.context.getTable(this.tableName).insertBulk(value, insertConfig);
+        return this.mapResultsToEntities(results);
+    }
+    /**
+     * Upsert with advanced configuration
+     * Auto-detects primary keys and supports chunking
+     */
+    async upsertBulk(values, config) {
+        // Convert typed config to base config
+        const baseConfig = {
+            chunkSize: config?.chunkSize,
+            overridingSystemValue: config?.overridingSystemValue,
+            targetWhere: config?.targetWhere,
+            setWhere: config?.setWhere,
+            referenceItem: config?.referenceItem,
+            updateColumnFilter: config?.updateColumnFilter,
+        };
+        // Handle primaryKey (can be lambda, string, or array)
+        if (config?.primaryKey) {
+            if (typeof config.primaryKey === 'function') {
+                // Lambda selector - extract property names
+                const pkProps = this.extractPropertyNames(config.primaryKey);
+                baseConfig.primaryKey = pkProps.length === 1 ? pkProps[0] : pkProps;
+            }
+            else {
+                // Direct string or array
+                baseConfig.primaryKey = config.primaryKey;
+            }
+        }
+        // Handle updateColumns (can be lambda or array)
+        if (config?.updateColumns) {
+            if (typeof config.updateColumns === 'function') {
+                // Lambda selector - extract property names
+                baseConfig.updateColumns = this.extractPropertyNames(config.updateColumns);
+            }
+            else {
+                // Direct array
+                baseConfig.updateColumns = config.updateColumns;
+            }
+        }
+        const results = await this.context.getTable(this.tableName).upsertBulk(values, baseConfig);
+        return this.mapResultsToEntities(results);
+    }
+    /**
+     * Map database column names back to property names
+     */
+    mapResultToEntity(result) {
+        const schema = this._getSchema();
+        const mapped = {};
+        for (const [propName, colBuilder] of Object.entries(schema.columns)) {
+            const config = colBuilder.build();
+            const dbColumnName = config.name;
+            if (dbColumnName in result) {
+                mapped[propName] = result[dbColumnName];
+            }
+        }
+        return mapped;
+    }
+    /**
+     * Map array of database results to entities
+     */
+    mapResultsToEntities(results) {
+        return results.map(r => this.mapResultToEntity(r));
+    }
+    /**
+     * Extract property names from lambda selector
+     */
+    extractPropertyNames(selector) {
+        const selectorStr = selector.toString();
+        // Match patterns like: e => e.username or e => ({ username: e.username, email: e.email })
+        const propertyNames = [];
+        // Simple property access: e => e.username
+        const simpleMatch = selectorStr.match(/=>\s*\w+\.(\w+)/);
+        if (simpleMatch) {
+            propertyNames.push(simpleMatch[1]);
+            return propertyNames;
+        }
+        // Object literal: e => ({ username: e.username, email: e.email })
+        const objectMatches = selectorStr.matchAll(/(\w+):\s*\w+\.\1/g);
+        for (const match of objectMatches) {
+            propertyNames.push(match[1]);
+        }
+        return propertyNames;
+    }
+    /**
+     * Start building an upsert query with values
+     */
+    values(data) {
+        const builder = this.context.getTable(this.tableName).values(data);
+        return new EntityInsertBuilder(builder);
+    }
+    /**
+     * Update records matching condition
+     * Usage: db.users.update({ age: 30 }, u => eq(u.id, 1))
+     */
+    async update(data, condition) {
+        const schema = this._getSchema();
+        const executor = this._getExecutor();
+        const client = this._getClient();
+        // Build SET clause
+        const setClauses = [];
+        const values = [];
+        let paramIndex = 1;
+        for (const [key, value] of Object.entries(data)) {
+            const column = schema.columns[key];
+            if (column) {
+                const config = column.build();
+                setClauses.push(`"${config.name}" = $${paramIndex++}`);
+                values.push(value);
+            }
+        }
+        if (setClauses.length === 0) {
+            throw new Error('No valid columns to update');
+        }
+        // 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, paramIndex);
+        values.push(...whereParams);
+        // Build RETURNING clause
+        const returningColumns = Object.entries(schema.columns)
+            .map(([_, col]) => `"${col.build().name}"`)
+            .join(', ');
+        const qualifiedTableName = this._getQualifiedTableName();
+        const sql = `
+      UPDATE ${qualifiedTableName}
+      SET ${setClauses.join(', ')}
+      WHERE ${whereSql}
+      RETURNING ${returningColumns}
+    `;
+        const result = executor
+            ? await executor.query(sql, values)
+            : await client.query(sql, values);
+        return this.mapResultsToEntities(result.rows);
+    }
+    /**
+     * Delete records matching condition
+     * Usage: db.users.delete(u => eq(u.id, 1))
+     */
+    async delete(condition) {
+        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);
+    }
+    /**
+     * Create a mock entity for type inference in lambdas
+     */
+    createMockEntity() {
+        const schema = this._getSchema();
+        const mock = {};
+        // Add all columns as DbColumn-like objects
+        for (const [propName, colBuilder] of Object.entries(schema.columns)) {
+            const config = colBuilder.build();
+            Object.defineProperty(mock, propName, {
+                get: () => ({
+                    __fieldName: propName,
+                    __dbColumnName: config.name,
+                    __isDbColumn: true,
+                }),
+                enumerable: true,
+            });
+        }
+        // Add navigation properties (both collections and references)
+        for (const [relName, relConfig] of Object.entries(schema.relations)) {
+            if (relConfig.type === 'many') {
+                Object.defineProperty(mock, relName, {
+                    get: () => {
+                        const targetSchema = relConfig.targetTableBuilder?.build();
+                        return new query_builder_1.CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
+                    },
+                    enumerable: true,
+                });
+            }
+            else {
+                // Single reference navigation (many-to-one, one-to-one)
+                Object.defineProperty(mock, relName, {
+                    get: () => {
+                        const targetSchema = relConfig.targetTableBuilder?.build();
+                        const refBuilder = new query_builder_1.ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
+                        return refBuilder.createMockTargetRow();
+                    },
+                    enumerable: true,
+                });
+            }
+        }
+        return mock;
+    }
+}
+exports.DbEntityTable = DbEntityTable;
+/**
+ * Base database context with entity-first approach
+ */
+class DatabaseContext extends DataContext {
+    constructor(client, queryOptions) {
+        // Initialize model config
+        const modelConfig = new model_config_1.DbModelConfig();
+        // Get the actual derived class's setupModel
+        const derivedPrototype = new.target.prototype;
+        if (derivedPrototype.setupModel) {
+            derivedPrototype.setupModel.call({ setupModel: derivedPrototype.setupModel }, modelConfig);
+        }
+        // Build schema from model
+        const schema = {};
+        const tables = modelConfig.buildTables();
+        for (const [tableName, tableBuilder] of tables) {
+            schema[tableName] = tableBuilder;
+        }
+        // Call parent with built schema
+        super(client, schema, queryOptions);
+        this.entityTables = new Map();
+        this.sequenceRegistry = new Map();
+        this.sequenceInstances = new Map();
+        this.modelConfig = modelConfig;
+        // Setup sequences after construction (call setupSequences if it exists)
+        if (derivedPrototype.setupSequences) {
+            derivedPrototype.setupSequences.call(this);
+        }
+    }
+    /**
+     * Hook called after database migrations/schema creation are complete.
+     * Override this method to execute custom SQL scripts that are outside the scope of the ORM.
+     *
+     * @example
+     * ```typescript
+     * protected async onMigrationComplete(client: DatabaseClient): Promise<void> {
+     *   // Create custom functions, views, triggers, etc.
+     *   await client.query(`
+     *     CREATE OR REPLACE FUNCTION custom_function()
+     *     RETURNS void AS $$
+     *     BEGIN
+     *       -- Custom logic here
+     *     END;
+     *     $$ LANGUAGE plpgsql;
+     *   `);
+     * }
+     * ```
+     *
+     * @param client - Database client for executing custom SQL
+     */
+    async onMigrationComplete(client) {
+        // Default implementation does nothing
+        // Override in derived class to execute custom scripts
+    }
+    /**
+     * Register a sequence in the schema
+     * @param config - Sequence configuration
+     */
+    registerSequence(config) {
+        const key = config.schema ? `${config.schema}.${config.name}` : config.name;
+        this.sequenceRegistry.set(key, config);
+    }
+    /**
+     * Get a sequence instance for interacting with the database
+     * @param config - Sequence configuration
+     * @returns DbSequence instance with nextValue() and resync() methods
+     */
+    sequence(config) {
+        const key = config.schema ? `${config.schema}.${config.name}` : config.name;
+        // Register if not already registered
+        if (!this.sequenceRegistry.has(key)) {
+            this.sequenceRegistry.set(key, config);
+        }
+        // Return cached instance or create new one
+        let instance = this.sequenceInstances.get(key);
+        if (!instance) {
+            instance = new sequence_builder_1.DbSequence(this.client, config);
+            this.sequenceInstances.set(key, instance);
+        }
+        return instance;
+    }
+    /**
+     * Get all registered sequences
+     * @internal
+     */
+    getSequenceRegistry() {
+        return this.sequenceRegistry;
+    }
+    /**
+     * Get schema manager for create/drop operations with post-migration hook support
+     */
+    getSchemaManager() {
+        return new db_schema_manager_1.DbSchemaManager(this.client, this.schemaRegistry, {
+            logQueries: this.queryOptions?.logQueries,
+            postMigrationHook: async (client) => {
+                await this.onMigrationComplete(client);
+            },
+            sequenceRegistry: this.sequenceRegistry
+        });
+    }
+    /**
+     * Get strongly-typed table accessor for an entity
+     * @internal - Use property accessors on derived class instead
+     */
+    table(entityClass) {
+        let table = this.entityTables.get(entityClass);
+        if (!table) {
+            const metadata = entity_base_1.EntityMetadataStore.getMetadata(entityClass);
+            if (!metadata) {
+                throw new Error(`No metadata found for entity ${entityClass.name}`);
+            }
+            // EntityTable doesn't need the tableBuilder, it just uses getTable() internally
+            table = new DbEntityTable(this, metadata.tableName, null);
+            this.entityTables.set(entityClass, table);
+        }
+        return table;
+    }
+}
+exports.DatabaseContext = DatabaseContext;
+//# sourceMappingURL=db-context.js.map