@relq/orm 0.1.0

package/dist/esm/select/join-many-condition-builder.js

@@ -0,0 +1,151 @@
+import { columnRefToSQL } from "./table-proxy.js";
+import { JoinConditionBuilder } from "./join-condition-builder.js";
+import { JOIN_INTERNAL, JOIN_SETUP } from "./join-internals.js";
+import format from "../shared/pg-format.js";
+export class JoinManyConditionBuilder extends JoinConditionBuilder {
+    orderSpecs = [];
+    limitValue;
+    offsetValue;
+    innerJoins = [];
+    proxyCreator;
+    rightProxy;
+    orderBy(column, direction = 'ASC', nulls) {
+        this.orderSpecs.push({ column, direction, nulls });
+        return this;
+    }
+    limit(count) {
+        this.limitValue = count;
+        return this;
+    }
+    offset(count) {
+        this.offsetValue = count;
+        return this;
+    }
+    get [JOIN_SETUP]() {
+        return (creator, rightProxy) => {
+            this.proxyCreator = creator;
+            this.rightProxy = rightProxy;
+        };
+    }
+    innerJoin(tableOrAlias, callback) {
+        if (!this.proxyCreator) {
+            throw new Error('innerJoin requires proxy creator - use raw innerJoinRaw() instead');
+        }
+        const [tableKey, alias] = Array.isArray(tableOrAlias)
+            ? tableOrAlias
+            : [tableOrAlias, tableOrAlias];
+        const { proxy: innerProxy, tableName } = this.proxyCreator(tableKey, alias);
+        const conditionBuilder = new JoinConditionBuilder();
+        callback(conditionBuilder, innerProxy);
+        const internals = conditionBuilder[JOIN_INTERNAL];
+        const onClause = internals.toSQL();
+        this.innerJoins.push({ type: 'JOIN', table: tableName, alias, onClause });
+        return this;
+    }
+    leftInnerJoin(tableOrAlias, callback) {
+        if (!this.proxyCreator) {
+            throw new Error('leftInnerJoin requires proxy creator - use raw leftInnerJoinRaw() instead');
+        }
+        const [tableKey, alias] = Array.isArray(tableOrAlias)
+            ? tableOrAlias
+            : [tableOrAlias, tableOrAlias];
+        const { proxy: innerProxy, tableName } = this.proxyCreator(tableKey, alias);
+        const conditionBuilder = new JoinConditionBuilder();
+        callback(conditionBuilder, innerProxy);
+        const internals = conditionBuilder[JOIN_INTERNAL];
+        const onClause = internals.toSQL();
+        this.innerJoins.push({ type: 'LEFT JOIN', table: tableName, alias, onClause });
+        return this;
+    }
+    innerJoinRaw(table, alias, onClause) {
+        this.innerJoins.push({ type: 'JOIN', table, alias, onClause });
+        return this;
+    }
+    leftInnerJoinRaw(table, alias, onClause) {
+        this.innerJoins.push({ type: 'LEFT JOIN', table, alias, onClause });
+        return this;
+    }
+    select(...args) {
+        if (args.length === 1 && Array.isArray(args[0])) {
+            this.selectedColumns = args[0];
+        }
+        else {
+            this.selectedColumns = args;
+        }
+        return this;
+    }
+    get [JOIN_INTERNAL]() {
+        return {
+            toSQL: () => this.buildSQL(),
+            isUsingJoin: () => false,
+            getUsingColumns: () => null,
+            toUsingSQL: () => null,
+            getConditions: () => [...this.conditions],
+            getWhereConditions: () => [...this.whereConditions],
+            hasConditions: () => this.conditions.length > 0,
+            hasWhereConditions: () => this.whereConditions.length > 0,
+            getSelectedColumns: () => this.selectedColumns ?? null,
+            toSelectSQL: (alias) => this.buildSelectSQL(alias),
+            toOrderBySQL: () => this.buildOrderBySQL(),
+            toLimitSQL: () => this.buildLimitSQL(),
+            toOffsetSQL: () => this.buildOffsetSQL(),
+            toWhereSQL: () => this.buildSQL(),
+            getInnerJoins: () => [...this.innerJoins],
+        };
+    }
+    buildSQL() {
+        const parts = [];
+        for (const cond of this.conditions) {
+            if (cond.type === 'raw') {
+                parts.push(cond.raw);
+            }
+            else if (cond.type !== 'using') {
+                const leftSQL = columnRefToSQL(cond.left);
+                const rightSQL = this.formatRightSide(cond.right);
+                parts.push(`${leftSQL} ${cond.operator} ${rightSQL}`);
+            }
+        }
+        if (this.whereConditions.length > 0) {
+            const { buildConditionsSQL } = require('../condition/condition-collector');
+            const whereSQL = buildConditionsSQL(this.whereConditions);
+            if (whereSQL) {
+                parts.push(whereSQL);
+            }
+        }
+        return parts.join(' AND ');
+    }
+    buildSelectSQL(tableAlias) {
+        if (!this.selectedColumns || this.selectedColumns.length === 0) {
+            return `${format.ident(tableAlias)}.*`;
+        }
+        return this.selectedColumns.map(col => `${format.ident(tableAlias)}.${format.ident(col)}`).join(', ');
+    }
+    buildOrderBySQL() {
+        if (this.orderSpecs.length === 0) {
+            return null;
+        }
+        return this.orderSpecs.map(spec => {
+            const col = format.ident(spec.column);
+            let sql = `${col} ${spec.direction}`;
+            if (spec.nulls) {
+                sql += ` NULLS ${spec.nulls}`;
+            }
+            return sql;
+        }).join(', ');
+    }
+    buildLimitSQL() {
+        if (this.limitValue === undefined) {
+            return null;
+        }
+        return `LIMIT ${this.limitValue}`;
+    }
+    buildOffsetSQL() {
+        if (this.offsetValue === undefined) {
+            return null;
+        }
+        return `OFFSET ${this.offsetValue}`;
+    }
+}
+export function createJoinManyConditionBuilder() {
+    return new JoinManyConditionBuilder();
+}

package/dist/esm/select/scalar-query-builder.js

@@ -0,0 +1,126 @@
+import format from "../shared/pg-format.js";
+import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
+class ScalarResultImpl {
+    sql;
+    params;
+    $scalar = true;
+    $type;
+    constructor(sql, params = []) {
+        this.sql = sql;
+        this.params = params;
+    }
+    toSQL() {
+        return this.sql;
+    }
+    getParams() {
+        return this.params;
+    }
+}
+export class ScalarQueryBuilderImpl {
+    tableName;
+    tableSchema;
+    columnResolver;
+    whereConditions = [];
+    constructor(tableName, tableSchema, columnResolver) {
+        this.tableName = tableName;
+        this.tableSchema = tableSchema;
+        this.columnResolver = columnResolver;
+    }
+    where(callback) {
+        const conditionBuilder = new ConditionCollector();
+        callback(conditionBuilder);
+        this.whereConditions.push(...conditionBuilder.getConditions());
+        return this;
+    }
+    count() {
+        const sql = this.buildSQL('COUNT(*)');
+        return new ScalarResultImpl(sql);
+    }
+    sum(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(SUM(${format.ident(sqlColumn)}), 0)`);
+        return new ScalarResultImpl(sql);
+    }
+    avg(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`COALESCE(AVG(${format.ident(sqlColumn)}), 0)`);
+        return new ScalarResultImpl(sql);
+    }
+    min(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MIN(${format.ident(sqlColumn)})`);
+        return new ScalarResultImpl(sql);
+    }
+    max(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(`MAX(${format.ident(sqlColumn)})`);
+        return new ScalarResultImpl(sql);
+    }
+    pick(column) {
+        const sqlColumn = this.resolveColumn(column);
+        const sql = this.buildSQL(format.ident(sqlColumn), true);
+        return new ScalarResultImpl(sql);
+    }
+    exists() {
+        const whereClause = this.buildWhereClause();
+        const sql = `(EXISTS(SELECT 1 FROM ${format.ident(this.tableName)}${whereClause}))`;
+        return new ScalarResultImpl(sql);
+    }
+    resolveColumn(column) {
+        if (this.columnResolver) {
+            return this.columnResolver(column);
+        }
+        const columns = this.tableSchema?.$columns || this.tableSchema;
+        const columnDef = columns?.[column];
+        if (columnDef?.$columnName) {
+            return columnDef.$columnName;
+        }
+        return column.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '');
+    }
+    transformConditions(conditions) {
+        if (!this.columnResolver && !this.tableSchema) {
+            return conditions;
+        }
+        return conditions.map(cond => {
+            if (!cond.column || cond.method === 'raw') {
+                return cond;
+            }
+            if (cond.method === 'or' || cond.method === 'and') {
+                return {
+                    ...cond,
+                    values: this.transformConditions(cond.values)
+                };
+            }
+            return {
+                ...cond,
+                column: this.resolveColumn(cond.column)
+            };
+        });
+    }
+    buildWhereClause() {
+        if (this.whereConditions.length === 0) {
+            return '';
+        }
+        const transformed = this.transformConditions(this.whereConditions);
+        return ` WHERE ${buildConditionsSQL(transformed)}`;
+    }
+    buildSQL(selectExpr, withLimit = false) {
+        const whereClause = this.buildWhereClause();
+        const limitClause = withLimit ? ' LIMIT 1' : '';
+        return `(SELECT ${selectExpr} FROM ${format.ident(this.tableName)}${whereClause}${limitClause})`;
+    }
+}
+export function createScalarTableAccessor(schema, getColumnResolver) {
+    return new Proxy({}, {
+        get(_, prop) {
+            if (typeof prop === 'symbol') {
+                return undefined;
+            }
+            const tables = schema?.tables || schema;
+            const tableDef = tables?.[prop];
+            const sqlTableName = tableDef?.$name || prop;
+            const columnResolver = getColumnResolver?.(sqlTableName);
+            return new ScalarQueryBuilderImpl(sqlTableName, tableDef, columnResolver);
+        }
+    });
+}

package/dist/esm/select/scalar-select-builder.js

@@ -0,0 +1,70 @@
+import format from "../shared/pg-format.js";
+import { createScalarTableAccessor } from "./scalar-query-builder.js";
+export class ScalarSelectBuilder {
+    executeQuery;
+    scalarResults;
+    constructor(scalars, schema, executeQuery, getColumnResolver) {
+        this.executeQuery = executeQuery;
+        const tableAccessor = createScalarTableAccessor(schema, getColumnResolver);
+        this.scalarResults = {};
+        for (const [key, callback] of Object.entries(scalars)) {
+            this.scalarResults[key] = callback(tableAccessor);
+        }
+    }
+    toString() {
+        const columns = Object.entries(this.scalarResults)
+            .map(([alias, scalar]) => `${scalar.toSQL()} AS ${format.ident(alias)}`)
+            .join(', ');
+        return `SELECT ${columns}`;
+    }
+    async get(withMetadata) {
+        const sql = this.toString();
+        const { data, metadata } = await this.executeQuery(sql);
+        const row = Array.isArray(data) ? data[0] : data;
+        const result = this.transformResult(row);
+        if (withMetadata) {
+            return { data: result, metadata };
+        }
+        return result;
+    }
+    transformResult(row) {
+        if (!row) {
+            const result = {};
+            for (const key of Object.keys(this.scalarResults)) {
+                result[key] = null;
+            }
+            return result;
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (typeof value === 'string' && /^\d+$/.test(value)) {
+                result[key] = parseInt(value, 10);
+            }
+            else if (typeof value === 'string' && /^\d+\.\d+$/.test(value)) {
+                result[key] = parseFloat(value);
+            }
+            else {
+                result[key] = value;
+            }
+        }
+        return result;
+    }
+}
+export class ConnectedScalarSelectBuilder extends ScalarSelectBuilder {
+    constructor(scalars, schema, internal) {
+        const executeQuery = async (sql) => {
+            return internal.executeSelectOne(sql);
+        };
+        const getColumnResolver = (tableName) => {
+            if (internal.hasColumnMapping()) {
+                return (column) => {
+                    const transformed = internal.transformToDbColumns(tableName, { [column]: null });
+                    const keys = Object.keys(transformed);
+                    return keys.length > 0 ? keys[0] : column;
+                };
+            }
+            return undefined;
+        };
+        super(scalars, schema, executeQuery, getColumnResolver);
+    }
+}