ts-prorm-orm 1.1.0

package/dist/query-builders/order-limit-builder.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * Order and Limit builder for the ORM
+ * Handles ORDER BY, LIMIT, and OFFSET clauses
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderLimitBuilder = exports.LimitOffsetBuilder = exports.OrderBuilder = void 0;
+exports.createOrderBuilder = createOrderBuilder;
+exports.createOrderLimitBuilder = createOrderLimitBuilder;
+exports.buildOrder = buildOrder;
+exports.buildLimitOffset = buildLimitOffset;
+/**
+ * OrderBuilder class for building ORDER BY clauses
+ */
+class OrderBuilder {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * Build an ORDER BY clause from Order options
+     */
+    build(order) {
+        if (!order) {
+            return { sql: '' };
+        }
+        const orderArray = Array.isArray(order) ? order : [order];
+        const orderParts = [];
+        for (const item of orderArray) {
+            const part = this.buildOrderItem(item);
+            if (part) {
+                orderParts.push(part);
+            }
+        }
+        if (orderParts.length === 0) {
+            return { sql: '' };
+        }
+        return { sql: `ORDER BY ${orderParts.join(', ')}` };
+    }
+    /**
+     * Build a single order item
+     */
+    buildOrderItem(item) {
+        // Handle string (raw SQL or "field ASC/DESC")
+        if (typeof item === 'string') {
+            return item;
+        }
+        // Handle OrderExpression from order helper functions (asc, desc, random)
+        if (item && typeof item === 'object' && item.__type === 'order') {
+            const direction = item.direction;
+            if (direction === 'RANDOM') {
+                // RANDOM() for SQLite/PostgreSQL, RAND() for MySQL/MariaDB
+                const dialectName = this.options.dialect?.name;
+                if (dialectName === 'mysql' || dialectName === 'mariadb') {
+                    return 'RAND()';
+                }
+                // Default to RANDOM() (SQLite/PostgreSQL)
+                return 'RANDOM()';
+            }
+            return `${this.escapeId(item.field)} ${direction}`;
+        }
+        // Handle array: ['field', 'ASC'] or [['field', 'ASC'], ['field2', 'DESC']]
+        if (Array.isArray(item)) {
+            // Check if it's a nested array (multiple order items)
+            if (item.length === 0) {
+                return null;
+            }
+            // If first element is an array, it's a list of order items
+            if (Array.isArray(item[0])) {
+                const parts = [];
+                for (const nestedItem of item) {
+                    const nestedPart = this.buildOrderItem(nestedItem);
+                    if (nestedPart) {
+                        parts.push(nestedPart);
+                    }
+                }
+                return parts.join(', ');
+            }
+            // Single order item: [field, direction] or [field]
+            const field = item[0];
+            const direction = item[1]?.toUpperCase() || 'ASC';
+            if (typeof field === 'string') {
+                return `${this.escapeId(field)} ${direction}`;
+            }
+            // Handle column reference: Op.col('column_name')
+            if (field && typeof field === 'object' && '$col' in field) {
+                const colRef = field;
+                return `${this.escapeId(colRef.$col)} ${direction}`;
+            }
+            // Handle [Model, 'field'] or [Model, ['field1', 'field2']]
+            if (field && typeof field === 'object') {
+                const model = field;
+                const modelName = model.tableName || model.name || String(model);
+                const fields = item[1];
+                if (Array.isArray(fields)) {
+                    // Multiple fields from model
+                    return fields
+                        .map((f) => `${this.escapeId(modelName)}.${this.escapeId(f)} ${direction}`)
+                        .join(', ');
+                }
+                return `${this.escapeId(modelName)}.${this.escapeId(String(fields))} ${direction}`;
+            }
+            return null;
+        }
+        // Handle object: { model: Model, as: 'alias', field: 'name', order: 'DESC' }
+        if (item && typeof item === 'object') {
+            const model = item.model;
+            const modelName = model?.tableName || model?.name || item.as || String(model);
+            const field = item.field || item.attribute;
+            const direction = item.order?.toUpperCase() || 'ASC';
+            if (field) {
+                return `${this.escapeId(modelName)}.${this.escapeId(String(field))} ${direction}`;
+            }
+            return null;
+        }
+        return null;
+    }
+    /**
+     * 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.OrderBuilder = OrderBuilder;
+/**
+ * LimitBuilder class for building LIMIT and OFFSET clauses
+ */
+class LimitOffsetBuilder {
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * Build LIMIT and OFFSET clauses
+     * Handles SQLite which requires LIMIT when using OFFSET
+     */
+    build(limit, offset) {
+        const parts = [];
+        // Check if we're using SQLite
+        const dialectName = this.options.dialect?.name;
+        const isSQLite = dialectName === 'sqlite';
+        if (limit !== undefined && limit !== null) {
+            const limitValue = Number(limit);
+            if (!isNaN(limitValue) && limitValue >= 0) {
+                parts.push(`LIMIT ${limitValue}`);
+                if (offset !== undefined && offset !== null) {
+                    const offsetValue = Number(offset);
+                    if (!isNaN(offsetValue) && offsetValue >= 0) {
+                        parts.push(`OFFSET ${offsetValue}`);
+                    }
+                }
+            }
+        }
+        else if (offset !== undefined && offset !== null) {
+            // If only offset is provided without limit
+            const offsetValue = Number(offset);
+            if (!isNaN(offsetValue) && offsetValue >= 0) {
+                if (isSQLite) {
+                    // SQLite requires LIMIT when using OFFSET
+                    // Use a very large limit to get all remaining rows
+                    parts.push(`LIMIT 9223372036854775807 OFFSET ${offsetValue}`);
+                }
+                else {
+                    // Other databases allow OFFSET without LIMIT
+                    parts.push(`OFFSET ${offsetValue}`);
+                }
+            }
+        }
+        return parts.join(' ');
+    }
+}
+exports.LimitOffsetBuilder = LimitOffsetBuilder;
+/**
+ * Combined Order and Limit builder
+ */
+class OrderLimitBuilder {
+    constructor(options = {}) {
+        this.orderBuilder = new OrderBuilder(options);
+        this.limitOffsetBuilder = new LimitOffsetBuilder(options);
+    }
+    /**
+     * Build ORDER BY clause
+     */
+    buildOrder(order) {
+        return this.orderBuilder.build(order);
+    }
+    /**
+     * Build LIMIT/OFFSET clause
+     */
+    buildLimitOffset(limit, offset) {
+        return this.limitOffsetBuilder.build(limit, offset);
+    }
+    /**
+     * Build both ORDER BY and LIMIT/OFFSET
+     */
+    build(order, limit, offset) {
+        const parts = [];
+        const orderResult = this.orderBuilder.build(order);
+        if (orderResult.sql) {
+            parts.push(orderResult.sql);
+        }
+        const limitOffset = this.limitOffsetBuilder.build(limit, offset);
+        if (limitOffset) {
+            parts.push(limitOffset);
+        }
+        return parts.join(' ');
+    }
+}
+exports.OrderLimitBuilder = OrderLimitBuilder;
+/**
+ * Create an OrderBuilder instance
+ */
+function createOrderBuilder(options) {
+    return new OrderBuilder(options);
+}
+/**
+ * Create an OrderLimitBuilder instance
+ */
+function createOrderLimitBuilder(options) {
+    return new OrderLimitBuilder(options);
+}
+/**
+ * Quick helper to build ORDER BY clause
+ */
+function buildOrder(order, options) {
+    const builder = new OrderBuilder(options);
+    return builder.build(order);
+}
+/**
+ * Quick helper to build LIMIT/OFFSET clause
+ */
+function buildLimitOffset(limit, offset) {
+    const builder = new LimitOffsetBuilder();
+    return builder.build(limit, offset);
+}
+exports.default = OrderLimitBuilder;