ts-prorm-orm 1.1.0

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

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Subquery Builder
+ * Provides an ORM-like way to build subqueries without raw SQL
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubqueryBuilder = void 0;
+const model_helpers_1 = require("./model-helpers");
+/**
+ * Builder for creating subqueries programmatically
+ */
+class SubqueryBuilder {
+    /**
+     * Create an IN subquery
+     * @example
+     * // Find users with posts using model class
+     * User.findAll({
+     *   where: {
+     *     id: { [Op.in]: SubqueryBuilder.select('userId', { model: Post }) }
+     *   }
+     * })
+     * @example
+     * // Using table name string
+     * SubqueryBuilder.select('userId', { model: 'posts' })
+     */
+    static select(column, options) {
+        const modelName = (0, model_helpers_1.getTableName)(options.model);
+        return `__SUBQUERY_${modelName}_${column}__`;
+    }
+    /**
+     * Create an EXISTS subquery
+     * @example
+     * // Find users who have posts using model class
+     * User.findAll({
+     *   where: {
+     *     [Op.exists]: SubqueryBuilder.exists({
+     *       model: Post,
+     *       where: { userId: { [Op.col]: 'User.id' } }
+     *     })
+     *   }
+     * })
+     * @example
+     * // Using table name string
+     * SubqueryBuilder.exists({ model: 'posts', where: {...} })
+     */
+    static exists(options) {
+        const modelName = (0, model_helpers_1.getTableName)(options.model);
+        return {
+            __type: 'exists',
+            model: modelName,
+            modelName: (0, model_helpers_1.getModelName)(options.model),
+            where: options.where,
+            correlation: options.correlation || 'INNER',
+        };
+    }
+    /**
+     * Create a NOT EXISTS subquery
+     */
+    static notExists(options) {
+        const modelName = (0, model_helpers_1.getTableName)(options.model);
+        return {
+            __type: 'notExists',
+            model: modelName,
+            modelName: (0, model_helpers_1.getModelName)(options.model),
+            where: options.where,
+            correlation: options.correlation || 'INNER',
+        };
+    }
+    /**
+     * Create a scalar subquery (COUNT, SUM, etc.)
+     * @example
+     * // Get user with post count using model class
+     * User.findAll({
+     *   attributes: {
+     *     include: [
+     *       [SubqueryBuilder.count({ model: Post, column: 'userId' }), 'postCount']
+     *     ]
+     *   }
+     * })
+     */
+    static count(options) {
+        const modelName = (0, model_helpers_1.getTableName)(options.model);
+        return {
+            __type: 'scalar',
+            aggregate: 'COUNT',
+            model: modelName,
+            modelName: (0, model_helpers_1.getModelName)(options.model),
+            column: options.column,
+            where: options.where,
+        };
+    }
+    static sum(options) {
+        const modelName = (0, model_helpers_1.getTableName)(options.model);
+        return {
+            __type: 'scalar',
+            aggregate: 'SUM',
+            model: modelName,
+            modelName: (0, model_helpers_1.getModelName)(options.model),
+            column: options.column,
+            where: options.where,
+        };
+    }
+    static avg(options) {
+        const modelName = (0, model_helpers_1.getTableName)(options.model);
+        return {
+            __type: 'scalar',
+            aggregate: 'AVG',
+            model: modelName,
+            modelName: (0, model_helpers_1.getModelName)(options.model),
+            column: options.column,
+            where: options.where,
+        };
+    }
+    static max(options) {
+        const modelName = (0, model_helpers_1.getTableName)(options.model);
+        return {
+            __type: 'scalar',
+            aggregate: 'MAX',
+            model: modelName,
+            modelName: (0, model_helpers_1.getModelName)(options.model),
+            column: options.column,
+            where: options.where,
+        };
+    }
+    static min(options) {
+        const modelName = (0, model_helpers_1.getTableName)(options.model);
+        return {
+            __type: 'scalar',
+            aggregate: 'MIN',
+            model: modelName,
+            modelName: (0, model_helpers_1.getModelName)(options.model),
+            column: options.column,
+            where: options.where,
+        };
+    }
+    /**
+     * Create a correlated subquery using column reference
+     * @example
+     * SubqueryBuilder.correlated({ outerModel: User, outerColumn: 'id', innerModel: Post, innerColumn: 'userId' })
+     */
+    static correlated(options) {
+        return {
+            __type: 'correlated',
+            outerModel: (0, model_helpers_1.getModelName)(options.outerModel),
+            outerColumn: options.outerColumn,
+            innerModel: (0, model_helpers_1.getModelName)(options.innerModel),
+            innerColumn: options.innerColumn,
+        };
+    }
+}
+exports.SubqueryBuilder = SubqueryBuilder;
+exports.default = SubqueryBuilder;

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

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Update query builder for the ORM
+ * Handles UPDATE queries with partial updates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateBuilder = void 0;
+exports.createUpdateBuilder = createUpdateBuilder;
+exports.buildUpdateQuery = buildUpdateQuery;
+exports.buildUpdateWithOperations = buildUpdateWithOperations;
+const where_builder_1 = require("./where-builder");
+/**
+ * UpdateBuilder class for building UPDATE queries
+ */
+class UpdateBuilder {
+    constructor(options = {}) {
+        this.options = options;
+        this.whereBuilder = new where_builder_1.WhereBuilder({
+            dialect: options.dialect,
+        });
+    }
+    /**
+     * Build an UPDATE query
+     */
+    build(tableName, values, where) {
+        const queryValues = [];
+        // Build SET clause
+        const setClauses = [];
+        for (const [key, value] of Object.entries(values)) {
+            if (value === undefined) {
+                continue;
+            }
+            // Handle column reference: Op.col('column_name')
+            if (value !== null && typeof value === 'object' && '$col' in value) {
+                const colName = value.$col;
+                setClauses.push(`${this.escapeId(key)} = ${this.escapeId(colName)}`);
+            }
+            else {
+                setClauses.push(`${this.escapeId(key)} = ?`);
+                queryValues.push(value);
+            }
+        }
+        if (setClauses.length === 0) {
+            throw new Error('No values to update');
+        }
+        const sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')}`;
+        // Build WHERE clause
+        const whereResult = this.whereBuilder.build(where);
+        let fullSql = sql;
+        if (whereResult.sql) {
+            fullSql += ` WHERE ${whereResult.sql}`;
+            queryValues.push(...whereResult.values);
+        }
+        // Add LIMIT if specified
+        if (this.options.limit !== undefined) {
+            fullSql += ` LIMIT ${this.options.limit}`;
+        }
+        // Add RETURNING clause if specified
+        if (this.options.returning) {
+            fullSql += this.buildReturningClause();
+        }
+        return { sql: fullSql, values: queryValues };
+    }
+    /**
+     * Build a partial UPDATE query (only specified fields)
+     */
+    buildPartial(tableName, values, where, fields) {
+        let filteredValues = values;
+        // Filter to only include specified fields
+        if (fields && fields.length > 0) {
+            filteredValues = {};
+            for (const field of fields) {
+                if (values[field] !== undefined) {
+                    filteredValues[field] = values[field];
+                }
+            }
+        }
+        return this.build(tableName, filteredValues, where);
+    }
+    /**
+     * Build an UPDATE query with increment/decrement operations
+     */
+    buildWithOperations(tableName, operations, where) {
+        const queryValues = [];
+        // Build SET clause with operations
+        const setClauses = [];
+        for (const [key, operation] of Object.entries(operations)) {
+            switch (operation.op) {
+                case '+':
+                    setClauses.push(`${this.escapeId(key)} = ${this.escapeId(key)} + ?`);
+                    break;
+                case '-':
+                    setClauses.push(`${this.escapeId(key)} = ${this.escapeId(key)} - ?`);
+                    break;
+                case '*':
+                    setClauses.push(`${this.escapeId(key)} = ${this.escapeId(key)} * ?`);
+                    break;
+                case '/':
+                    setClauses.push(`${this.escapeId(key)} = ${this.escapeId(key)} / ?`);
+                    break;
+                case 'SET':
+                    setClauses.push(`${this.escapeId(key)} = ?`);
+                    break;
+            }
+            queryValues.push(operation.value);
+        }
+        if (setClauses.length === 0) {
+            throw new Error('No operations to update');
+        }
+        const sql = `UPDATE ${this.escapeId(tableName)} SET ${setClauses.join(', ')}`;
+        // Build WHERE clause
+        const whereResult = this.whereBuilder.build(where);
+        let fullSql = sql;
+        if (whereResult.sql) {
+            fullSql += ` WHERE ${whereResult.sql}`;
+            queryValues.push(...whereResult.values);
+        }
+        // Add LIMIT if specified
+        if (this.options.limit !== undefined) {
+            fullSql += ` LIMIT ${this.options.limit}`;
+        }
+        return { sql: fullSql, values: queryValues };
+    }
+    /**
+     * Build a batch UPDATE query (for bulk updates)
+     */
+    buildBatch(tableName, records) {
+        const results = [];
+        for (const record of records) {
+            results.push(this.build(tableName, record.values, record.where));
+        }
+        return results;
+    }
+    /**
+     * 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.UpdateBuilder = UpdateBuilder;
+/**
+ * Create an UpdateBuilder instance
+ */
+function createUpdateBuilder(options) {
+    return new UpdateBuilder(options);
+}
+/**
+ * Quick helper to build an UPDATE query
+ */
+function buildUpdateQuery(tableName, values, where, options) {
+    const builder = new UpdateBuilder(options);
+    return builder.build(tableName, values, where);
+}
+/**
+ * Quick helper to build an UPDATE query with increment/decrement
+ */
+function buildUpdateWithOperations(tableName, operations, where, options) {
+    const builder = new UpdateBuilder(options);
+    return builder.buildWithOperations(tableName, operations, where);
+}
+exports.default = UpdateBuilder;

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

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * View Builder
+ * Provides an ORM-like way to create database views
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewBuilder = void 0;
+exports.createViewBuilder = createViewBuilder;
+const model_helpers_1 = require("./model-helpers");
+/**
+ * Builder for creating database views
+ */
+class ViewBuilder {
+    constructor() {
+        this.columns = [];
+        this.joins = [];
+    }
+    /**
+     * Set the primary model to select from
+     * Accepts model class or table name string
+     * @example
+     * .from(User)
+     * .from('users')
+     */
+    from(model) {
+        this.fromModel = model;
+        return this;
+    }
+    /**
+     * Add a column to select
+     */
+    selectColumn(column, opts) {
+        this.columns.push({
+            name: opts?.alias || column,
+            expression: opts?.expression || column,
+            alias: opts?.alias,
+        });
+        return this;
+    }
+    /**
+     * Add multiple columns at once
+     */
+    selectColumns(columns) {
+        columns.forEach(col => this.selectColumn(col));
+        return this;
+    }
+    /**
+     * Add all columns from a model
+     */
+    selectAll(model, opts) {
+        // If it's a model class with attributes, we could use those
+        // For now, just use * in the SQL
+        return this;
+    }
+    /**
+     * Add a join to the view
+     * @example
+     * .join({ model: Post, type: 'LEFT', on: { userId: 'users.id' } })
+     * .join({ model: 'posts', type: 'LEFT', on: { userId: 'users.id' } })
+     */
+    join(opts) {
+        this.joins.push({
+            model: opts.model,
+            type: opts.type || 'INNER',
+            on: opts.on,
+            as: opts.as,
+        });
+        return this;
+    }
+    /**
+     * Add WHERE conditions
+     */
+    where(conditions) {
+        this.whereConditions = conditions;
+        return this;
+    }
+    /**
+     * Add GROUP BY
+     */
+    groupBy(columns) {
+        this.groupByClause = columns;
+        return this;
+    }
+    /**
+     * Add HAVING conditions
+     */
+    having(conditions) {
+        this.havingConditions = conditions;
+        return this;
+    }
+    /**
+     * Add ORDER BY
+     */
+    orderBy(order) {
+        this.orderByClause = order;
+        return this;
+    }
+    /**
+     * Add LIMIT
+     */
+    limit(limit) {
+        this.limitVal = limit;
+        return this;
+    }
+    /**
+     * Add OFFSET
+     */
+    offset(offset) {
+        this.offsetVal = offset;
+        return this;
+    }
+    /**
+     * Add DISTINCT
+     */
+    distinct() {
+        this.distinctVal = true;
+        return this;
+    }
+    /**
+     * Set view options
+     */
+    options(opts) {
+        this.viewOptions = opts;
+        return this;
+    }
+    /**
+     * Get the view options
+     */
+    getOptions() {
+        return this.viewOptions || {};
+    }
+    /**
+     * Build the SELECT query for the view
+     */
+    toSelectQuery() {
+        return {
+            model: this.fromModel,
+            columns: this.columns.map(c => c.alias || c.name),
+            joins: this.joins,
+            where: this.whereConditions,
+            group: this.groupByClause,
+            having: this.havingConditions,
+            order: this.orderByClause,
+            limit: this.limitVal,
+            offset: this.offsetVal,
+            distinct: this.distinctVal,
+        };
+    }
+    /**
+     * Build and return the SQL string
+     */
+    toSQL(dialect) {
+        const selectParts = [];
+        if (this.distinctVal) {
+            selectParts.push('DISTINCT');
+        }
+        if (this.columns.length > 0) {
+            const colExprs = this.columns.map(c => {
+                if (typeof c.expression === 'string') {
+                    return c.alias ? `${c.expression} AS ${dialect.escapeId(c.alias)}` : c.expression;
+                }
+                return c.expression.column;
+            });
+            selectParts.push(colExprs.join(', '));
+        }
+        else {
+            selectParts.push('*');
+        }
+        let sql = `SELECT ${selectParts.join(' ')}`;
+        if (this.fromModel) {
+            const tableName = (0, model_helpers_1.getTableName)(this.fromModel);
+            sql += ` FROM ${dialect.quoteTable(tableName)}`;
+        }
+        for (const join of this.joins) {
+            const joinType = join.type || 'INNER';
+            const tableName = (0, model_helpers_1.getTableName)(join.model);
+            sql += ` ${joinType} JOIN ${dialect.quoteTable(tableName)}`;
+            if (join.as) {
+                sql += ` AS ${dialect.escapeId(join.as)}`;
+            }
+        }
+        if (this.groupByClause) {
+            const cols = Array.isArray(this.groupByClause) ? this.groupByClause.join(', ') : this.groupByClause;
+            sql += ` GROUP BY ${cols}`;
+        }
+        if (this.limitVal) {
+            sql += ` LIMIT ${this.limitVal}`;
+        }
+        if (this.offsetVal) {
+            sql += ` OFFSET ${this.offsetVal}`;
+        }
+        return sql;
+    }
+    /**
+     * Reset the builder
+     */
+    reset() {
+        this.columns = [];
+        this.fromModel = undefined;
+        this.joins = [];
+        this.whereConditions = undefined;
+        this.groupByClause = undefined;
+        this.havingConditions = undefined;
+        this.orderByClause = undefined;
+        this.limitVal = undefined;
+        this.offsetVal = undefined;
+        this.distinctVal = undefined;
+        this.viewOptions = undefined;
+    }
+}
+exports.ViewBuilder = ViewBuilder;
+/**
+ * Create a new view builder
+ */
+function createViewBuilder() {
+    return new ViewBuilder();
+}
+exports.default = { ViewBuilder, createViewBuilder };