@relq/orm 0.1.0

package/dist/esm/core/helpers/ConnectedCountBuilder.js

@@ -0,0 +1,69 @@
+import { INTERNAL } from "./methods.js";
+import { createTableAccessor } from "../shared/table-accessor.js";
+export class ConnectedCountBuilder {
+    builder;
+    relq;
+    tableName;
+    groupNames = [];
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    group(name, callback, options) {
+        this.groupNames.push(name);
+        this.builder.group(name, (q) => {
+            const wrapped = this.wrapConditionBuilder(q);
+            return callback(wrapped);
+        }, options);
+        return this;
+    }
+    where(callback) {
+        this.builder.where((q) => {
+            q._tables = createTableAccessor(this.relq, this.relq.schema);
+            const wrapped = this.wrapConditionBuilder(q);
+            return callback(wrapped);
+        });
+        return this;
+    }
+    wrapConditionBuilder(originalBuilder) {
+        const relq = this.relq;
+        const tableName = this.tableName;
+        const createProxy = (target) => {
+            return new Proxy(target, {
+                get(target, prop) {
+                    const original = target[prop];
+                    if (typeof original === 'function') {
+                        return function (column, ...args) {
+                            const transformed = relq[INTERNAL].transformToDbColumns(tableName, { [column]: true });
+                            const dbColumn = Object.keys(transformed)[0] || column;
+                            const result = original.call(target, dbColumn, ...args);
+                            if (result === target || (result && typeof result === 'object')) {
+                                return createProxy(result);
+                            }
+                            return result;
+                        };
+                    }
+                    return original;
+                }
+            });
+        };
+        return createProxy(originalBuilder);
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async get() {
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeQuery(sql);
+        const row = result.result.rows[0];
+        if (this.groupNames.length === 0) {
+            return (Number(row?.count) ?? 0);
+        }
+        const counts = {};
+        for (const name of this.groupNames) {
+            counts[name] = Number(row?.[name] ?? 0);
+        }
+        return counts;
+    }
+}

package/dist/esm/core/helpers/ConnectedDeleteBuilder.js

@@ -0,0 +1,61 @@
+import { INTERNAL } from "./methods.js";
+import { ReturningExecutor } from "./ReturningExecutor.js";
+import { requireCapability } from "./capability-guard.js";
+import { createTableAccessor } from "../shared/table-accessor.js";
+export class ConnectedDeleteBuilder {
+    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[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;
+        });
+    }
+    where(callback) {
+        this.builder.where((q) => {
+            q._tables = createTableAccessor(this.relq, this.relq.schema);
+            return callback(q);
+        });
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        if (columns === null) {
+            return this;
+        }
+        requireCapability(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the DELETE to retrieve deleted data');
+        this.builder.returning(columns);
+        return new ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
+    }
+}

package/dist/esm/core/helpers/ConnectedInsertBuilder.js

@@ -0,0 +1,108 @@
+import { ConditionCollector, buildConditionsSQL } from "../../condition/condition-collector.js";
+import { debugLog, INTERNAL } from "./methods.js";
+import { ReturningExecutor } from "./ReturningExecutor.js";
+import { requireCapability } from "./capability-guard.js";
+export 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[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 ConditionCollector();
+                where(collector);
+                const conditions = collector.getConditions();
+                if (conditions.length > 0) {
+                    const whereClause = buildConditionsSQL(conditions);
+                    conflictBuilder.where(whereClause);
+                }
+            }
+        });
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async run(withMetadata) {
+        debugLog(this.relq[INTERNAL]?.config, `ConnectedInsertBuilder.run called for table: ${this.builder.tableName}`);
+        const internalRelq = this.relq[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;
+        }
+        requireCapability(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the INSERT to retrieve inserted data');
+        this.builder.returning(columns);
+        return new ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
+    }
+}

package/dist/esm/core/helpers/ConnectedInsertFromSelectBuilder.js

@@ -0,0 +1,62 @@
+import { debugLog, INTERNAL } from "./methods.js";
+import { ReturningExecutor } from "./ReturningExecutor.js";
+import { requireCapability } from "./capability-guard.js";
+export 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[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) {
+        debugLog(this.relq[INTERNAL]?.config, `ConnectedInsertFromSelectBuilder.run called for table: ${this.builder.tableName}`);
+        const sql = this.builder.toString();
+        const result = await this.relq[INTERNAL].executeRun(sql);
+        if (withMetadata) {
+            return result;
+        }
+        return result.metadata.rowCount ?? 0;
+    }
+    returning(columns) {
+        if (columns === null) {
+            return this;
+        }
+        requireCapability(this.relq, 'returning', 'RETURNING clause', 'Use a SELECT query after the INSERT to retrieve inserted data');
+        this.builder.returning(columns);
+        return new ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
+    }
+}

package/dist/esm/core/helpers/ConnectedQueryBuilder.js

@@ -0,0 +1,142 @@
+import { CountBuilder } from "../../count/count-builder.js";
+import { DeleteBuilder } from "../../delete/delete-builder.js";
+import { InsertBuilder } from "../../insert/insert-builder.js";
+import { InsertFromSelectBuilder } from "../../insert/insert-from-select-builder.js";
+import { AggregateQueryBuilder } from "../../select/aggregate-builder.js";
+import { SelectBuilder } from "../../select/select-builder.js";
+import { UpdateBuilder } from "../../update/update-builder.js";
+import { ConnectedAggregateBuilder } from "./ConnectedAggregateBuilder.js";
+import { ConnectedCountBuilder } from "./ConnectedCountBuilder.js";
+import { ConnectedDeleteBuilder } from "./ConnectedDeleteBuilder.js";
+import { ConnectedInsertBuilder } from "./ConnectedInsertBuilder.js";
+import { ConnectedInsertFromSelectBuilder } from "./ConnectedInsertFromSelectBuilder.js";
+import { ConnectedSelectBuilder } from "./ConnectedSelectBuilder.js";
+import { ConnectedUpdateBuilder } from "./ConnectedUpdateBuilder.js";
+import { INTERNAL } from "./methods.js";
+import { PaginateBuilder } from "./PaginateBuilder.js";
+import { createTableAccessor } from "../shared/table-accessor.js";
+import { executeFindById, executeFindOne, executeFindMany, executeExists, executeUpsert, executeCreateWith, executeSoftDelete, executeRestore, getPrimaryKeyColumn } from "./query-convenience.js";
+export 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[INTERNAL].hasColumnMapping()) {
+            if (Array.isArray(columns)) {
+                dbColumns = columns.map(col => {
+                    if (Array.isArray(col)) {
+                        const transformed = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [col[0]]: true });
+                        return [Object.keys(transformed)[0], col[1]];
+                    }
+                    else {
+                        const transformed = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [col]: true });
+                        return Object.keys(transformed)[0];
+                    }
+                });
+            }
+            else {
+                const transformed = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [columns]: true });
+                dbColumns = Object.keys(transformed)[0];
+            }
+        }
+        const builder = new SelectBuilder(this.tableName, dbColumns);
+        return new 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 InsertBuilder(this.tableName, {});
+            builder.clear();
+            return new ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
+        }
+        const builder = new InsertBuilder(this.tableName, rows[0]);
+        for (let i = 1; i < rows.length; i++) {
+            builder.addRow(rows[i]);
+        }
+        return new ConnectedInsertBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    update(data) {
+        const builder = new UpdateBuilder(this.tableName, data);
+        return new ConnectedUpdateBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    delete() {
+        const builder = new DeleteBuilder(this.tableName);
+        return new ConnectedDeleteBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    count() {
+        const builder = new CountBuilder(this.tableName);
+        return new ConnectedCountBuilder(builder, this.relq, this.tableName);
+    }
+    aggregate() {
+        const builder = new AggregateQueryBuilder(this.tableName);
+        return new ConnectedAggregateBuilder(builder, this.relq, this.tableName);
+    }
+    async findById(id) {
+        return executeFindById(this.ctx, id, () => getPrimaryKeyColumn(this.relq, this.tableName));
+    }
+    async findOne(filter) {
+        return executeFindOne(this.ctx, filter);
+    }
+    async findMany(filter) {
+        return executeFindMany(this.ctx, filter);
+    }
+    async exists(filter) {
+        return executeExists(this.ctx, filter);
+    }
+    async upsert(options) {
+        return executeUpsert(this.ctx, {
+            where: options.where,
+            create: options.create,
+            update: options.update,
+        });
+    }
+    insertFrom(columns, selectCallback) {
+        const tables = createTableAccessor(this.relq, this.relq.schema);
+        const selectQuery = selectCallback(tables);
+        const builder = new InsertFromSelectBuilder(this.tableName, columns, selectQuery.toString());
+        return new ConnectedInsertFromSelectBuilder(builder, this.relq, this.tableName, this.schemaKey);
+    }
+    paginate(options = {}) {
+        return new PaginateBuilder(this.relq, this.tableName, options.columns, options.where, options.orderBy);
+    }
+    async createWith(options) {
+        return executeCreateWith(this.ctx, options.data, options.with);
+    }
+    async softDelete(filter) {
+        return executeSoftDelete(this.ctx, filter);
+    }
+    async restore(filter) {
+        return executeRestore(this.ctx, filter);
+    }
+}

package/dist/esm/core/helpers/ConnectedRawQueryBuilder.js

@@ -0,0 +1,42 @@
+import { RawQueryBuilder } from "../../raw/index.js";
+import { INTERNAL } from "./methods.js";
+export 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 RawQueryBuilder(convertedQuery, this.params);
+    }
+    convertPlaceholders(query) {
+        let index = 0;
+        return query.replace(/\?/g, () => `$${++index}`);
+    }
+    async all() {
+        const sql = this.builder.toString();
+        return this.relq[INTERNAL].executeSelect(sql);
+    }
+    async get() {
+        const sql = this.builder.toString();
+        return this.relq[INTERNAL].executeSelectOne(sql);
+    }
+    async getMany(count) {
+        const sql = this.builder.toString();
+        const limitedSql = sql.toUpperCase().includes('LIMIT')
+            ? sql
+            : `${sql} LIMIT ${count}`;
+        return this.relq[INTERNAL].executeSelect(limitedSql);
+    }
+    async run() {
+        const sql = this.builder.toString();
+        return this.relq[INTERNAL].executeRun(sql);
+    }
+    async count() {
+        const sql = this.builder.toString();
+        return this.relq[INTERNAL].executeCount(sql);
+    }
+}