@relq/orm 0.1.0

package/dist/cjs/core/helpers/ConnectedInsertBuilder.cjs

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedInsertBuilder = void 0;
+const condition_collector_1 = require("../../condition/condition-collector.cjs");
+const methods_1 = require("./methods.cjs");
+const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+const capability_guard_1 = require("./capability-guard.cjs");
+class ConnectedInsertBuilder {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey) {
+            return;
+        }
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef) {
+            return;
+        }
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+        this.builder.setColumnTypeResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (!columnDef) {
+                return undefined;
+            }
+            const type = columnDef.$type;
+            if (typeof type !== 'string') {
+                return undefined;
+            }
+            const isArray = columnDef.$array === true;
+            const baseType = type.replace(/\[\]$/, '').toLowerCase();
+            return { type: baseType, isArray };
+        });
+    }
+    addRow(row) {
+        this.builder.addRow(row);
+        return this;
+    }
+    addRows(rows) {
+        this.builder.addRows(rows);
+        return this;
+    }
+    clear() {
+        this.builder.clear();
+        return this;
+    }
+    get total() {
+        return this.builder.total;
+    }
+    doNothing(...args) {
+        const columns = [...new Set(args.flat())];
+        this.builder._onConflict(columns.length > 0 ? columns : null, q => q.doNothing());
+        return this;
+    }
+    doUpdate(columns, values, where) {
+        const cols = [...new Set(Array.isArray(columns) ? columns : [columns])];
+        this.builder._onConflict(cols, (conflictBuilder) => {
+            conflictBuilder.doUpdate(values);
+            if (where) {
+                const collector = new condition_collector_1.ConditionCollector();
+                where(collector);
+                const conditions = collector.getConditions();
+                if (conditions.length > 0) {
+                    const whereClause = (0, condition_collector_1.buildConditionsSQL)(conditions);
+                    conflictBuilder.where(whereClause);
+                }
+            }
+        });
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        (0, methods_1.debugLog)(this.relq[methods_1.INTERNAL]?.config, `ConnectedInsertBuilder.run called for table: ${this.builder.tableName}`);
+        const internalRelq = this.relq[methods_1.INTERNAL];
+        for (const row of this.builder.insertData) {
+            internalRelq.validateData(this.builder.tableName, row, 'insert');
+        }
+        const sql = this.builder.toString();
+        const result = await internalRelq.executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        if (columns === null) {
+            return this;
+        }
+        (0, capability_guard_1.requireCapability)(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the INSERT to retrieve inserted data');
+        this.builder.returning(columns);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
+    }
+}
+exports.ConnectedInsertBuilder = ConnectedInsertBuilder;

package/dist/cjs/core/helpers/ConnectedInsertFromSelectBuilder.cjs

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedInsertFromSelectBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+const capability_guard_1 = require("./capability-guard.cjs");
+class ConnectedInsertFromSelectBuilder {
+    builder;
+    relq;
+    tableName;
+    schemaKey;
+    constructor(builder, relq, tableName, schemaKey) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+        this.schemaKey = schemaKey;
+        this.setupColumnResolver();
+    }
+    setupColumnResolver() {
+        if (!this.tableName && !this.schemaKey)
+            return;
+        const internal = this.relq[methods_1.INTERNAL];
+        const tableDef = internal.getTableDef(this.schemaKey || this.tableName);
+        if (!tableDef)
+            return;
+        const tableColumns = tableDef.$columns || tableDef;
+        this.builder.setColumnResolver((column) => {
+            const columnDef = tableColumns[column];
+            if (columnDef) {
+                return columnDef.$columnName || column;
+            }
+            return column;
+        });
+    }
+    doNothing(...args) {
+        const columns = [...new Set(args.flat())];
+        this.builder.onConflictDoNothing(columns.length > 0 ? columns : undefined);
+        return this;
+    }
+    doUpdate(columns, updateData) {
+        const cols = Array.isArray(columns) ? columns : [columns];
+        this.builder.onConflictDoUpdate(cols, updateData);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        (0, methods_1.debugLog)(this.relq[methods_1.INTERNAL]?.config, `ConnectedInsertFromSelectBuilder.run called for table: ${this.builder.tableName}`);
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        if (columns === null) {
+            return this;
+        }
+        (0, capability_guard_1.requireCapability)(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the INSERT to retrieve inserted data');
+        this.builder.returning(columns);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
+    }
+}
+exports.ConnectedInsertFromSelectBuilder = ConnectedInsertFromSelectBuilder;

package/dist/cjs/core/helpers/ConnectedQueryBuilder.cjs

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedQueryBuilder = void 0;
+const count_builder_1 = require("../../count/count-builder.cjs");
+const delete_builder_1 = require("../../delete/delete-builder.cjs");
+const insert_builder_1 = require("../../insert/insert-builder.cjs");
+const insert_from_select_builder_1 = require("../../insert/insert-from-select-builder.cjs");
+const aggregate_builder_1 = require("../../select/aggregate-builder.cjs");
+const select_builder_1 = require("../../select/select-builder.cjs");
+const update_builder_1 = require("../../update/update-builder.cjs");
+const ConnectedAggregateBuilder_1 = require("./ConnectedAggregateBuilder.cjs");
+const ConnectedCountBuilder_1 = require("./ConnectedCountBuilder.cjs");
+const ConnectedDeleteBuilder_1 = require("./ConnectedDeleteBuilder.cjs");
+const ConnectedInsertBuilder_1 = require("./ConnectedInsertBuilder.cjs");
+const ConnectedInsertFromSelectBuilder_1 = require("./ConnectedInsertFromSelectBuilder.cjs");
+const ConnectedSelectBuilder_1 = require("./ConnectedSelectBuilder.cjs");
+const ConnectedUpdateBuilder_1 = require("./ConnectedUpdateBuilder.cjs");
+const methods_1 = require("./methods.cjs");
+const PaginateBuilder_1 = require("./PaginateBuilder.cjs");
+const table_accessor_1 = require("../shared/table-accessor.cjs");
+const query_convenience_1 = require("./query-convenience.cjs");
+class ConnectedQueryBuilder {
+    tableName;
+    relq;
+    schemaKey;
+    constructor(tableName, relq, schemaKey) {
+        this.tableName = tableName;
+        this.relq = relq;
+        this.schemaKey = schemaKey;
+    }
+    get ctx() {
+        return { relq: this.relq, tableName: this.tableName };
+    }
+    select(...args) {
+        let columns;
+        if (args.length === 0) {
+            columns = undefined;
+        }
+        else if (args.length === 1) {
+            columns = args[0];
+        }
+        else {
+            columns = args;
+        }
+        if (columns !== undefined) {
+            if (Array.isArray(columns)) {
+                if (columns.length === 0) {
+                    throw new Error('select() requires at least one column. Use .select() without arguments for SELECT *');
+                }
+            }
+            else if (typeof columns === 'string') {
+                if (columns === '' || columns === '*') {
+                    throw new Error(`Invalid column name: "${columns}". Use .select() without arguments for SELECT *, or specify column names`);
+                }
+            }
+        }
+        let dbColumns = columns;
+        if (columns && this.relq[methods_1.INTERNAL].hasColumnMapping()) {
+            if (Array.isArray(columns)) {
+                dbColumns = columns.map(col => {
+                    if (Array.isArray(col)) {
+                        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [col[0]]: true });
+                        return [Object.keys(transformed)[0], col[1]];
+                    }
+                    else {
+                        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [col]: true });
+                        return Object.keys(transformed)[0];
+                    }
+                });
+            }
+            else {
+                const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [columns]: true });
+                dbColumns = Object.keys(transformed)[0];
+            }
+        }
+        const builder = new select_builder_1.SelectBuilder(this.tableName, dbColumns);
+        return new ConnectedSelectBuilder_1.ConnectedSelectBuilder(builder, this.relq, this.tableName, columns, this.schemaKey);
+    }
+    insert(data) {
+        const rows = Array.isArray(data) ? data : [data];
+        if (rows.length === 0) {
+            const builder = new insert_builder_1.InsertBuilder(this.tableName, {});
+            builder.clear();
+            return new ConnectedInsertBuilder_1.ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
+        }
+        const builder = new insert_builder_1.InsertBuilder(this.tableName, rows[0]);
+        for (let i = 1; i < rows.length; i++) {
+            builder.addRow(rows[i]);
+        }
+        return new ConnectedInsertBuilder_1.ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    update(data) {
+        const builder = new update_builder_1.UpdateBuilder(this.tableName, data);
+        return new ConnectedUpdateBuilder_1.ConnectedUpdateBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    delete() {
+        const builder = new delete_builder_1.DeleteBuilder(this.tableName);
+        return new ConnectedDeleteBuilder_1.ConnectedDeleteBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    count() {
+        const builder = new count_builder_1.CountBuilder(this.tableName);
+        return new ConnectedCountBuilder_1.ConnectedCountBuilder(builder, this.relq, this.tableName);
+    }
+    aggregate() {
+        const builder = new aggregate_builder_1.AggregateQueryBuilder(this.tableName);
+        return new ConnectedAggregateBuilder_1.ConnectedAggregateBuilder(builder, this.relq, this.tableName);
+    }
+    async findById(id) {
+        return (0, query_convenience_1.executeFindById)(this.ctx, id, () => (0, query_convenience_1.getPrimaryKeyColumn)(this.relq, this.tableName));
+    }
+    async findOne(filter) {
+        return (0, query_convenience_1.executeFindOne)(this.ctx, filter);
+    }
+    async findMany(filter) {
+        return (0, query_convenience_1.executeFindMany)(this.ctx, filter);
+    }
+    async exists(filter) {
+        return (0, query_convenience_1.executeExists)(this.ctx, filter);
+    }
+    async upsert(options) {
+        return (0, query_convenience_1.executeUpsert)(this.ctx, {
+            where: options.where,
+            create: options.create,
+            update: options.update,
+        });
+    }
+    insertFrom(columns, selectCallback) {
+        const tables = (0, table_accessor_1.createTableAccessor)(this.relq, this.relq.schema);
+        const selectQuery = selectCallback(tables);
+        const builder = new insert_from_select_builder_1.InsertFromSelectBuilder(this.tableName, columns, selectQuery.toString());
+        return new ConnectedInsertFromSelectBuilder_1.ConnectedInsertFromSelectBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    paginate(options = {}) {
+        return new PaginateBuilder_1.PaginateBuilder(this.relq, this.tableName, options.columns, options.where, options.orderBy);
+    }
+    async createWith(options) {
+        return (0, query_convenience_1.executeCreateWith)(this.ctx, options.data, options.with);
+    }
+    async softDelete(filter) {
+        return (0, query_convenience_1.executeSoftDelete)(this.ctx, filter);
+    }
+    async restore(filter) {
+        return (0, query_convenience_1.executeRestore)(this.ctx, filter);
+    }
+}
+exports.ConnectedQueryBuilder = ConnectedQueryBuilder;

package/dist/cjs/core/helpers/ConnectedRawQueryBuilder.cjs

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedRawQueryBuilder = void 0;
+const raw_1 = require("../../raw/index.cjs");
+const methods_1 = require("./methods.cjs");
+class ConnectedRawQueryBuilder {
+    query;
+    params;
+    relq;
+    builder;
+    constructor(query, params, relq) {
+        this.query = query;
+        this.params = params;
+        this.relq = relq;
+        const convertedQuery = this.convertPlaceholders(query);
+        this.builder = new raw_1.RawQueryBuilder(convertedQuery, this.params);
+    }
+    convertPlaceholders(query) {
+        let index = 0;
+        return query.replace(/\?/g, () => `$${++index}`);
+    }
+    async all() {
+        const sql = this.builder.toString();
+        return this.relq[methods_1.INTERNAL].executeSelect(sql);
+    }
+    async get() {
+        const sql = this.builder.toString();
+        return this.relq[methods_1.INTERNAL].executeSelectOne(sql);
+    }
+    async getMany(count) {
+        const sql = this.builder.toString();
+        const limitedSql = sql.toUpperCase().includes('LIMIT')
+            ? sql
+            : `${sql} LIMIT ${count}`;
+        return this.relq[methods_1.INTERNAL].executeSelect(limitedSql);
+    }
+    async run() {
+        const sql = this.builder.toString();
+        return this.relq[methods_1.INTERNAL].executeRun(sql);
+    }
+    async count() {
+        const sql = this.builder.toString();
+        return this.relq[methods_1.INTERNAL].executeCount(sql);
+    }
+}
+exports.ConnectedRawQueryBuilder = ConnectedRawQueryBuilder;