ts-prorm-orm 1.1.0

package/dist/query-builders/index-expression-builder.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Index Expression Builder
+ * Provides ORM-like way to create functional indexes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexExpressionBuilder = void 0;
+exports.createIndexBuilder = createIndexBuilder;
+const model_helpers_1 = require("./model-helpers");
+/**
+ * Builder for index expressions
+ */
+class IndexExpressionBuilder {
+    constructor() {
+        this.columns = [];
+    }
+    /**
+     * Add a simple column to the index
+     */
+    column(name, opts) {
+        this.columns.push({
+            name,
+            length: opts?.length,
+            order: opts?.order,
+        });
+        return this;
+    }
+    /**
+     * Add a functional index using a column reference
+     */
+    functional(column, opts) {
+        const modelName = opts?.model ? (0, model_helpers_1.getTableName)(opts.model) : undefined;
+        this.columns.push({
+            name: column,
+            expression: {
+                __type: 'column',
+                model: modelName,
+                column,
+            },
+            length: opts?.length,
+            order: opts?.order,
+        });
+        return this;
+    }
+    /**
+     * Add LOWER(column) expression
+     */
+    lower(column, opts) {
+        this.columns.push({
+            name: `LOWER(${column})`,
+            expression: {
+                __type: 'function',
+                name: 'LOWER',
+                args: [{ __type: 'column', column }],
+            },
+            order: opts?.order,
+        });
+        return this;
+    }
+    /**
+     * Add UPPER(column) expression
+     */
+    upper(column, opts) {
+        this.columns.push({
+            name: `UPPER(${column})`,
+            expression: {
+                __type: 'function',
+                name: 'UPPER',
+                args: [{ __type: 'column', column }],
+            },
+            order: opts?.order,
+        });
+        return this;
+    }
+    /**
+     * Add LENGTH(column) expression
+     */
+    length(column, opts) {
+        this.columns.push({
+            name: `LENGTH(${column})`,
+            expression: {
+                __type: 'function',
+                name: 'LENGTH',
+                args: [{ __type: 'column', column }],
+            },
+            order: opts?.order,
+        });
+        return this;
+    }
+    /**
+     * Add SUBSTRING(column FROM start FOR length) expression
+     */
+    substring(column, start, length, opts) {
+        const args = [
+            { __type: 'column', column },
+            { __type: 'literal', value: start, type: 'number' },
+        ];
+        if (length) {
+            args.push({ __type: 'literal', value: length, type: 'number' });
+        }
+        this.columns.push({
+            name: `SUBSTRING(${column} FROM ${start}${length ? ' FOR ' + length : ''})`,
+            expression: {
+                __type: 'function',
+                name: 'SUBSTRING',
+                args,
+            },
+            order: opts?.order,
+        });
+        return this;
+    }
+    /**
+     * Add a custom function expression
+     */
+    fn(name, args, alias) {
+        const exprString = args.map(arg => {
+            if (typeof arg === 'string')
+                return arg;
+            if (arg.__type === 'column')
+                return arg.column;
+            if (arg.__type === 'literal')
+                return String(arg.value);
+            return '';
+        }).join(', ');
+        this.columns.push({
+            name: alias || `${name}(${exprString})`,
+            expression: {
+                __type: 'function',
+                name,
+                args,
+            },
+        });
+        return this;
+    }
+    /**
+     * Add COALESCE expression for handling NULLs
+     */
+    coalesce(column, defaultValue) {
+        this.columns.push({
+            name: `COALESCE(${column}, ${defaultValue})`,
+            expression: {
+                __type: 'function',
+                name: 'COALESCE',
+                args: [
+                    { __type: 'column', column },
+                    { __type: 'literal', value: defaultValue },
+                ],
+            },
+        });
+        return this;
+    }
+    /**
+     * Add CAST expression
+     */
+    cast(column, asType) {
+        this.columns.push({
+            name: `CAST(${column} AS ${asType})`,
+            expression: {
+                __type: 'function',
+                name: 'CAST',
+                args: [
+                    { __type: 'column', column },
+                    { __type: 'literal', value: asType, type: 'string' },
+                ],
+            },
+        });
+        return this;
+    }
+    /**
+     * Add JSON extract expression (PostgreSQL)
+     */
+    jsonExtract(column, path) {
+        this.columns.push({
+            name: `${column}->>'${path}'`,
+            expression: {
+                __type: 'function',
+                name: 'JSON_EXTRACT',
+                args: [
+                    { __type: 'column', column },
+                    { __type: 'literal', value: path, type: 'string' },
+                ],
+            },
+        });
+        return this;
+    }
+    /**
+     * Get all index columns
+     */
+    getColumns() {
+        return this.columns;
+    }
+    /**
+     * Build the index column expressions
+     */
+    toSQL(dialect) {
+        return this.columns.map(col => {
+            let expr = col.name;
+            if (col.expression) {
+                if (col.expression.__type === 'function') {
+                    const fn = col.expression;
+                    const args = fn.args.map(arg => {
+                        if (typeof arg === 'string')
+                            return arg;
+                        if (arg.__type === 'column')
+                            return dialect.escapeId(arg.column);
+                        if (arg.__type === 'literal')
+                            return dialect.escape(arg.value);
+                        return '';
+                    }).join(', ');
+                    expr = `${fn.name}(${args})`;
+                }
+                else if (col.expression.__type === 'column') {
+                    expr = dialect.escapeId(col.expression.column);
+                }
+            }
+            else {
+                expr = dialect.escapeId(col.name);
+            }
+            if (col.length) {
+                expr += ` (${col.length})`;
+            }
+            if (col.order) {
+                expr += ` ${col.order}`;
+            }
+            return expr;
+        }).join(', ');
+    }
+    /**
+     * Reset the builder
+     */
+    reset() {
+        this.columns = [];
+    }
+}
+exports.IndexExpressionBuilder = IndexExpressionBuilder;
+/**
+ * Create a new index expression builder
+ */
+function createIndexBuilder() {
+    return new IndexExpressionBuilder();
+}
+exports.default = { IndexExpressionBuilder, createIndexBuilder };

package/dist/query-builders/index.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Query Builders
+ * Exports all query builder classes and utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlCompilerDefault = exports.buildUpdateWithOperations = exports.buildUpdateQuery = exports.createUpdateBuilder = exports.UpdateBuilder = exports.buildBulkInsertQuery = exports.buildInsertQuery = exports.createInsertBuilder = exports.InsertBuilder = exports.buildLimitOffset = exports.buildOrder = exports.createOrderLimitBuilder = exports.createOrderBuilder = exports.OrderLimitBuilder = exports.LimitOffsetBuilder = exports.OrderBuilder = exports.buildIncludes = exports.createIncludeBuilder = exports.IncludeBuilder = exports.buildWhereClause = exports.createWhereBuilder = exports.WhereBuilder = exports.createIndexBuilder = exports.IndexExpressionBuilder = exports.createViewBuilder = exports.ViewBuilder = exports.SubqueryBuilder = exports.createCTEBuilder = exports.CTEBuilder = exports.SqlCompiler = exports.isModel = exports.getModelName = exports.getTableName = void 0;
+exports.createQueryBuilder = createQueryBuilder;
+exports.createQuickQuery = createQuickQuery;
+exports.getDefaultQueryBuilder = getDefaultQueryBuilder;
+exports.setDefaultQueryBuilder = setDefaultQueryBuilder;
+// Export model helpers
+var model_helpers_1 = require("./model-helpers");
+Object.defineProperty(exports, "getTableName", { enumerable: true, get: function () { return model_helpers_1.getTableName; } });
+Object.defineProperty(exports, "getModelName", { enumerable: true, get: function () { return model_helpers_1.getModelName; } });
+Object.defineProperty(exports, "isModel", { enumerable: true, get: function () { return model_helpers_1.isModel; } });
+// Export SQL compiler
+var sql_compiler_1 = require("./sql-compiler");
+Object.defineProperty(exports, "SqlCompiler", { enumerable: true, get: function () { return sql_compiler_1.SqlCompiler; } });
+// Export CTE builder
+var cte_builder_1 = require("./cte-builder");
+Object.defineProperty(exports, "CTEBuilder", { enumerable: true, get: function () { return cte_builder_1.CTEBuilder; } });
+Object.defineProperty(exports, "createCTEBuilder", { enumerable: true, get: function () { return cte_builder_1.createCTEBuilder; } });
+// Export subquery builder
+var subquery_builder_1 = require("./subquery-builder");
+Object.defineProperty(exports, "SubqueryBuilder", { enumerable: true, get: function () { return subquery_builder_1.SubqueryBuilder; } });
+// Export view builder
+var view_builder_1 = require("./view-builder");
+Object.defineProperty(exports, "ViewBuilder", { enumerable: true, get: function () { return view_builder_1.ViewBuilder; } });
+Object.defineProperty(exports, "createViewBuilder", { enumerable: true, get: function () { return view_builder_1.createViewBuilder; } });
+// Export index expression builder
+var index_expression_builder_1 = require("./index-expression-builder");
+Object.defineProperty(exports, "IndexExpressionBuilder", { enumerable: true, get: function () { return index_expression_builder_1.IndexExpressionBuilder; } });
+Object.defineProperty(exports, "createIndexBuilder", { enumerable: true, get: function () { return index_expression_builder_1.createIndexBuilder; } });
+// Export modular query builders
+var where_builder_1 = require("./where-builder");
+Object.defineProperty(exports, "WhereBuilder", { enumerable: true, get: function () { return where_builder_1.WhereBuilder; } });
+Object.defineProperty(exports, "createWhereBuilder", { enumerable: true, get: function () { return where_builder_1.createWhereBuilder; } });
+Object.defineProperty(exports, "buildWhereClause", { enumerable: true, get: function () { return where_builder_1.buildWhereClause; } });
+var include_builder_1 = require("./include-builder");
+Object.defineProperty(exports, "IncludeBuilder", { enumerable: true, get: function () { return include_builder_1.IncludeBuilder; } });
+Object.defineProperty(exports, "createIncludeBuilder", { enumerable: true, get: function () { return include_builder_1.createIncludeBuilder; } });
+Object.defineProperty(exports, "buildIncludes", { enumerable: true, get: function () { return include_builder_1.buildIncludes; } });
+var order_limit_builder_1 = require("./order-limit-builder");
+Object.defineProperty(exports, "OrderBuilder", { enumerable: true, get: function () { return order_limit_builder_1.OrderBuilder; } });
+Object.defineProperty(exports, "LimitOffsetBuilder", { enumerable: true, get: function () { return order_limit_builder_1.LimitOffsetBuilder; } });
+Object.defineProperty(exports, "OrderLimitBuilder", { enumerable: true, get: function () { return order_limit_builder_1.OrderLimitBuilder; } });
+Object.defineProperty(exports, "createOrderBuilder", { enumerable: true, get: function () { return order_limit_builder_1.createOrderBuilder; } });
+Object.defineProperty(exports, "createOrderLimitBuilder", { enumerable: true, get: function () { return order_limit_builder_1.createOrderLimitBuilder; } });
+Object.defineProperty(exports, "buildOrder", { enumerable: true, get: function () { return order_limit_builder_1.buildOrder; } });
+Object.defineProperty(exports, "buildLimitOffset", { enumerable: true, get: function () { return order_limit_builder_1.buildLimitOffset; } });
+var insert_builder_1 = require("./insert-builder");
+Object.defineProperty(exports, "InsertBuilder", { enumerable: true, get: function () { return insert_builder_1.InsertBuilder; } });
+Object.defineProperty(exports, "createInsertBuilder", { enumerable: true, get: function () { return insert_builder_1.createInsertBuilder; } });
+Object.defineProperty(exports, "buildInsertQuery", { enumerable: true, get: function () { return insert_builder_1.buildInsertQuery; } });
+Object.defineProperty(exports, "buildBulkInsertQuery", { enumerable: true, get: function () { return insert_builder_1.buildBulkInsertQuery; } });
+var update_builder_1 = require("./update-builder");
+Object.defineProperty(exports, "UpdateBuilder", { enumerable: true, get: function () { return update_builder_1.UpdateBuilder; } });
+Object.defineProperty(exports, "createUpdateBuilder", { enumerable: true, get: function () { return update_builder_1.createUpdateBuilder; } });
+Object.defineProperty(exports, "buildUpdateQuery", { enumerable: true, get: function () { return update_builder_1.buildUpdateQuery; } });
+Object.defineProperty(exports, "buildUpdateWithOperations", { enumerable: true, get: function () { return update_builder_1.buildUpdateWithOperations; } });
+/**
+ * Create a query builder with the given options
+ */
+function createQueryBuilder(options) {
+    // Import dynamically to avoid circular dependencies
+    const { SqlCompiler } = require('./sql-compiler');
+    const sqlCompiler = new SqlCompiler(undefined, {
+        parameterized: options?.parameterized,
+        paramChar: options?.paramChar,
+    });
+    return {
+        sqlCompiler,
+    };
+}
+/**
+ * Quick query helper for simple queries
+ */
+function createQuickQuery(dialect) {
+    const { SqlCompiler } = require('./sql-compiler');
+    const compiler = new SqlCompiler();
+    return {
+        /**
+         * Build a simple SELECT query
+         */
+        select: (table, where) => {
+            return compiler.compileSelect({
+                tableName: table,
+                where,
+            });
+        },
+        /**
+         * Build a simple INSERT query
+         */
+        insert: (table, values) => {
+            return compiler.compileInsert({
+                tableName: table,
+                values,
+            });
+        },
+        /**
+         * Build a simple UPDATE query
+         */
+        update: (table, values, where) => {
+            return compiler.compileUpdate({
+                tableName: table,
+                values,
+                where,
+            });
+        },
+        /**
+         * Build a simple DELETE query
+         */
+        delete: (table, where) => {
+            return compiler.compileDelete({
+                tableName: table,
+                where,
+            });
+        },
+        /**
+         * Build a WHERE clause
+         */
+        where: (conditions) => {
+            return compiler.compileWhere(conditions);
+        },
+        /**
+         * Build an ORDER BY clause
+         */
+        order: (order) => {
+            return compiler.compileOrder(order);
+        },
+        /**
+         * Build a LIMIT/OFFSET clause
+         */
+        limitOffset: (limit, offset) => {
+            return compiler.compileLimitOffset(limit, offset);
+        },
+    };
+}
+/**
+ * Default query builder instance
+ */
+let defaultQueryBuilder = null;
+/**
+ * Get or create the default query builder
+ */
+function getDefaultQueryBuilder() {
+    if (!defaultQueryBuilder) {
+        defaultQueryBuilder = createQuickQuery();
+    }
+    return defaultQueryBuilder;
+}
+/**
+ * Set the default query builder
+ */
+function setDefaultQueryBuilder(builder) {
+    defaultQueryBuilder = builder;
+}
+// Re-export for default export
+var sql_compiler_2 = require("./sql-compiler");
+Object.defineProperty(exports, "SqlCompilerDefault", { enumerable: true, get: function () { return sql_compiler_2.SqlCompiler; } });

package/dist/query-builders/insert-builder.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * Insert query builder for the ORM
+ * Handles INSERT queries including bulk inserts and upserts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsertBuilder = void 0;
+exports.createInsertBuilder = createInsertBuilder;
+exports.buildInsertQuery = buildInsertQuery;
+exports.buildBulkInsertQuery = buildBulkInsertQuery;
+/**
+ * InsertBuilder class for building INSERT queries
+ */
+class InsertBuilder {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * Build an INSERT query for a single record
+     */
+    build(tableName, values) {
+        const queryValues = [];
+        const columns = Object.keys(values);
+        if (columns.length === 0) {
+            return {
+                sql: `INSERT INTO ${this.escapeId(tableName)} DEFAULT VALUES`,
+                values: [],
+            };
+        }
+        const placeholders = columns.map(() => '?').join(', ');
+        const columnSql = columns.map((c) => this.escapeId(c)).join(', ');
+        let sql = `INSERT INTO ${this.escapeId(tableName)} (${columnSql}) VALUES (${placeholders})`;
+        // Add query values
+        queryValues.push(...Object.values(values));
+        // Handle upsert (ON CONFLICT)
+        if (this.options.upsert) {
+            sql = this.buildUpsert(sql, columns, values);
+        }
+        // Handle RETURNING clause
+        if (this.options.returning) {
+            sql += this.buildReturningClause();
+        }
+        return { sql, values: queryValues };
+    }
+    /**
+     * Build a bulk INSERT query
+     */
+    buildBulk(tableName, records) {
+        if (records.length === 0) {
+            return { sql: '', values: [] };
+        }
+        // Get all unique columns from all records
+        const columnSet = new Set();
+        for (const record of records) {
+            Object.keys(record).forEach((key) => columnSet.add(key));
+        }
+        const columns = Array.from(columnSet);
+        const columnSql = columns.map((c) => this.escapeId(c)).join(', ');
+        // Build values for each record
+        const values = [];
+        const valueTuples = [];
+        for (const record of records) {
+            const placeholders = columns
+                .map((col) => {
+                const value = record[col];
+                values.push(value);
+                return '?';
+            })
+                .join(', ');
+            valueTuples.push(`(${placeholders})`);
+        }
+        let sql = `INSERT INTO ${this.escapeId(tableName)} (${columnSql}) VALUES ${valueTuples.join(', ')}`;
+        // Handle bulk upsert
+        if (this.options.upsert) {
+            sql = this.buildBulkUpsert(sql, columns);
+        }
+        // Handle RETURNING clause
+        if (this.options.returning) {
+            sql += this.buildReturningClause();
+        }
+        return { sql, values };
+    }
+    /**
+     * Build an upsert (INSERT ... ON CONFLICT) query
+     */
+    buildUpsert(baseSql, columns, values) {
+        const conflictFields = this.options.conflictFields || columns;
+        // Build the ON CONFLICT clause
+        const conflictColumns = conflictFields.map((c) => this.escapeId(c)).join(', ');
+        // Build the DO UPDATE SET clause
+        const updateSet = columns
+            .filter((col) => !conflictFields.includes(col) || values[col] !== undefined)
+            .map((col) => `${this.escapeId(col)} = excluded.${this.escapeId(col)}`)
+            .join(', ');
+        if (updateSet) {
+            return `${baseSql} ON CONFLICT (${conflictColumns}) DO UPDATE SET ${updateSet}`;
+        }
+        // If no columns to update, do nothing (just ignore conflict)
+        return `${baseSql} ON CONFLICT (${conflictColumns}) DO NOTHING`;
+    }
+    /**
+     * Build a bulk upsert query
+     */
+    buildBulkUpsert(baseSql, columns) {
+        const conflictFields = this.options.conflictFields || columns;
+        const conflictColumns = conflictFields.map((c) => this.escapeId(c)).join(', ');
+        const updateSet = columns
+            .filter((col) => !conflictFields.includes(col))
+            .map((col) => `${this.escapeId(col)} = excluded.${this.escapeId(col)}`)
+            .join(', ');
+        if (updateSet) {
+            return `${baseSql} ON CONFLICT (${conflictColumns}) DO UPDATE SET ${updateSet}`;
+        }
+        return `${baseSql} ON CONFLICT (${conflictColumns}) DO NOTHING`;
+    }
+    /**
+     * Build the RETURNING clause
+     */
+    buildReturningClause() {
+        if (!this.options.returning) {
+            return '';
+        }
+        if (this.options.returning === true) {
+            return ' RETURNING *';
+        }
+        if (Array.isArray(this.options.returning)) {
+            const cols = this.options.returning.map((c) => this.escapeId(c)).join(', ');
+            return ` RETURNING ${cols}`;
+        }
+        return '';
+    }
+    /**
+     * Escape an identifier
+     */
+    escapeId(identifier) {
+        const id = String(identifier ?? '');
+        if (this.options.dialect?.escapeId) {
+            return this.options.dialect.escapeId(id);
+        }
+        return `"${id.replace(/"/g, '""')}"`;
+    }
+}
+exports.InsertBuilder = InsertBuilder;
+/**
+ * Create an InsertBuilder instance
+ */
+function createInsertBuilder(options) {
+    return new InsertBuilder(options);
+}
+/**
+ * Quick helper to build an INSERT query
+ */
+function buildInsertQuery(tableName, values, options) {
+    const builder = new InsertBuilder(options);
+    return builder.build(tableName, values);
+}
+/**
+ * Quick helper to build a bulk INSERT query
+ */
+function buildBulkInsertQuery(tableName, records, options) {
+    const builder = new InsertBuilder(options);
+    return builder.buildBulk(tableName, records);
+}
+exports.default = InsertBuilder;

package/dist/query-builders/model-helpers.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Model Helpers
+ * Utilities for working with Model classes in builders
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableName = getTableName;
+exports.isModel = isModel;
+exports.getModelName = getModelName;
+/**
+ * Get table name from a model class or string
+ */
+function getTableName(model) {
+    if (typeof model === 'string') {
+        return model;
+    }
+    return model.tableName || model.name || '';
+}
+/**
+ * Check if value is a model class (has tableName or name property)
+ */
+function isModel(value) {
+    if (!value || typeof value === 'string') {
+        return false;
+    }
+    const anyVal = value;
+    return !!(anyVal.tableName || anyVal.name);
+}
+/**
+ * Get model name from model class
+ */
+function getModelName(model) {
+    if (typeof model === 'string') {
+        return model;
+    }
+    return model.name || model.tableName || '';
+}
+exports.default = { getTableName, isModel, getModelName };