@relq/orm 0.1.0

package/dist/cjs/condition/postgis-condition-builder.cjs

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgisConditionCollector = void 0;
+exports.buildPostgisConditionSQL = buildPostgisConditionSQL;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+function isGeoJson(input) {
+    return typeof input === 'object' && input !== null && 'type' in input && 'coordinates' in input;
+}
+function geometryInputToSQL(input) {
+    if (isGeoJson(input)) {
+        return { sql: JSON.stringify(input), isGeoJson: true };
+    }
+    return { sql: input, isGeoJson: false };
+}
+class PostgisConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    contains(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_contains',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    within(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_within',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    intersects(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_intersects',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    overlaps(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_overlaps',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    crosses(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_crosses',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    touches(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_touches',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    disjoint(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_disjoint',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    equals(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_equals',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    dwithin(column, geometry, distance) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_dwithin',
+            column,
+            values: { geometry: sql, isGeoJson, distance }
+        });
+        return this.parent;
+    }
+    distanceLessThan(column, geometry, distance) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_distance_lt',
+            column,
+            values: { geometry: sql, isGeoJson, distance }
+        });
+        return this.parent;
+    }
+    distanceGreaterThan(column, geometry, distance) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_distance_gt',
+            column,
+            values: { geometry: sql, isGeoJson, distance }
+        });
+        return this.parent;
+    }
+    coveredBy(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_covered_by',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+    covers(column, geometry) {
+        const { sql, isGeoJson } = geometryInputToSQL(geometry);
+        this.parent.conditions.push({
+            method: 'postgis_covers',
+            column,
+            values: { geometry: sql, isGeoJson }
+        });
+        return this.parent;
+    }
+}
+exports.PostgisConditionCollector = PostgisConditionCollector;
+function formatGeometrySQL(geometry, isGeoJson) {
+    if (isGeoJson) {
+        return (0, pg_format_1.default)('ST_GeomFromGeoJSON(%L)', geometry);
+    }
+    return (0, pg_format_1.default)('ST_GeomFromText(%L)', geometry);
+}
+function buildPostgisConditionSQL(condition) {
+    const { method, column, values } = condition;
+    const { geometry, isGeoJson } = values;
+    const geomSQL = formatGeometrySQL(geometry, isGeoJson);
+    switch (method) {
+        case 'postgis_contains':
+            return (0, pg_format_1.default)('ST_Contains(%I, ', column) + geomSQL + ')';
+        case 'postgis_within':
+            return (0, pg_format_1.default)('ST_Within(%I, ', column) + geomSQL + ')';
+        case 'postgis_intersects':
+            return (0, pg_format_1.default)('ST_Intersects(%I, ', column) + geomSQL + ')';
+        case 'postgis_overlaps':
+            return (0, pg_format_1.default)('ST_Overlaps(%I, ', column) + geomSQL + ')';
+        case 'postgis_crosses':
+            return (0, pg_format_1.default)('ST_Crosses(%I, ', column) + geomSQL + ')';
+        case 'postgis_touches':
+            return (0, pg_format_1.default)('ST_Touches(%I, ', column) + geomSQL + ')';
+        case 'postgis_disjoint':
+            return (0, pg_format_1.default)('ST_Disjoint(%I, ', column) + geomSQL + ')';
+        case 'postgis_equals':
+            return (0, pg_format_1.default)('ST_Equals(%I, ', column) + geomSQL + ')';
+        case 'postgis_dwithin': {
+            const { distance } = values;
+            return (0, pg_format_1.default)('ST_DWithin(%I, ', column) + geomSQL + (0, pg_format_1.default)(', %s)', distance);
+        }
+        case 'postgis_distance_lt': {
+            const { distance } = values;
+            return (0, pg_format_1.default)('ST_Distance(%I, ', column) + geomSQL + (0, pg_format_1.default)(') < %s', distance);
+        }
+        case 'postgis_distance_gt': {
+            const { distance } = values;
+            return (0, pg_format_1.default)('ST_Distance(%I, ', column) + geomSQL + (0, pg_format_1.default)(') > %s', distance);
+        }
+        case 'postgis_covered_by':
+            return (0, pg_format_1.default)('ST_CoveredBy(%I, ', column) + geomSQL + ')';
+        case 'postgis_covers':
+            return (0, pg_format_1.default)('ST_Covers(%I, ', column) + geomSQL + ')';
+        default:
+            return '';
+    }
+}

package/dist/cjs/condition/range-condition-builder.cjs

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RangeConditionCollector = void 0;
+exports.buildRangeConditionSQL = buildRangeConditionSQL;
+const pg_format_1 = __importDefault(require("../shared/pg-format.cjs"));
+function rangeToSQL(range) {
+    if (typeof range === 'string')
+        return range;
+    if (Array.isArray(range)) {
+        const [start, end] = range;
+        const startStr = start instanceof Date ? start.toISOString() : String(start);
+        const endStr = end instanceof Date ? end.toISOString() : String(end);
+        return `[${startStr},${endStr})`;
+    }
+    const rangeObj = range;
+    const startBracket = rangeObj.startBound === 'exclusive' ? '(' : '[';
+    const endBracket = rangeObj.endBound === 'inclusive' ? ']' : ')';
+    const startStr = rangeObj.start instanceof Date ? rangeObj.start.toISOString() : String(rangeObj.start);
+    const endStr = rangeObj.end instanceof Date ? rangeObj.end.toISOString() : String(rangeObj.end);
+    return `${startBracket}${startStr},${endStr}${endBracket}`;
+}
+class RangeConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    contains(column, value) {
+        this.parent.conditions.push({
+            method: 'range_contains',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    containedBy(column, range) {
+        this.parent.conditions.push({
+            method: 'range_contained_by',
+            column,
+            values: rangeToSQL(range)
+        });
+        return this.parent;
+    }
+    overlaps(column, range) {
+        this.parent.conditions.push({
+            method: 'range_overlaps',
+            column,
+            values: rangeToSQL(range)
+        });
+        return this.parent;
+    }
+    strictlyLeft(column, range) {
+        this.parent.conditions.push({
+            method: 'range_strictly_left',
+            column,
+            values: rangeToSQL(range)
+        });
+        return this.parent;
+    }
+    strictlyRight(column, range) {
+        this.parent.conditions.push({
+            method: 'range_strictly_right',
+            column,
+            values: rangeToSQL(range)
+        });
+        return this.parent;
+    }
+    adjacent(column, range) {
+        this.parent.conditions.push({
+            method: 'range_adjacent',
+            column,
+            values: rangeToSQL(range)
+        });
+        return this.parent;
+    }
+}
+exports.RangeConditionCollector = RangeConditionCollector;
+function buildRangeConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'range_contains':
+            return (0, pg_format_1.default)('%I @> %L', column, values);
+        case 'range_contained_by':
+            return (0, pg_format_1.default)('%I <@ %L', column, values);
+        case 'range_overlaps':
+            return (0, pg_format_1.default)('%I && %L', column, values);
+        case 'range_strictly_left':
+            return (0, pg_format_1.default)('%I << %L', column, values);
+        case 'range_strictly_right':
+            return (0, pg_format_1.default)('%I >> %L', column, values);
+        case 'range_adjacent':
+            return (0, pg_format_1.default)('%I -|- %L', column, values);
+        default:
+            return '';
+    }
+}

package/dist/cjs/core/helpers/ConnectedAggregateBuilder.cjs

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedAggregateBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+const table_accessor_1 = require("../shared/table-accessor.cjs");
+class ConnectedAggregateBuilder {
+    builder;
+    relq;
+    tableName;
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    mapColumn(column) {
+        const transformed = this.relq[methods_1.INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
+        return Object.keys(transformed)[0] || column;
+    }
+    groupBy(...columns) {
+        const dbColumns = columns.map(col => this.mapColumn(col));
+        this.builder.groupBy(...dbColumns);
+        return this;
+    }
+    count(alias) {
+        this.builder.count(alias);
+        return this;
+    }
+    countColumn(column, alias) {
+        this.builder.countColumn(this.mapColumn(column), alias);
+        return this;
+    }
+    countDistinct(column, alias) {
+        this.builder.countDistinct(this.mapColumn(column), alias);
+        return this;
+    }
+    sum(column, alias) {
+        this.builder.sum(this.mapColumn(column), alias);
+        return this;
+    }
+    avg(column, alias) {
+        this.builder.avg(this.mapColumn(column), alias);
+        return this;
+    }
+    min(column, alias) {
+        this.builder.min(this.mapColumn(column), alias);
+        return this;
+    }
+    max(column, alias) {
+        this.builder.max(this.mapColumn(column), alias);
+        return this;
+    }
+    arrayAgg(column, alias) {
+        this.builder.arrayAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    stringAgg(column, delimiter, alias) {
+        this.builder.stringAgg(this.mapColumn(column), delimiter || ', ', alias);
+        return this;
+    }
+    jsonAgg(column, alias) {
+        this.builder.jsonAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    jsonbAgg(column, alias) {
+        this.builder.jsonbAgg(this.mapColumn(column), alias);
+        return this;
+    }
+    boolAnd(column, alias) {
+        this.builder.boolAnd(this.mapColumn(column), alias);
+        return this;
+    }
+    boolOr(column, alias) {
+        this.builder.boolOr(this.mapColumn(column), alias);
+        return this;
+    }
+    where(callback) {
+        this.builder.where((q) => {
+            q._tables = (0, table_accessor_1.createTableAccessor)(this.relq, this.relq.schema);
+            return callback(q);
+        });
+        return this;
+    }
+    having(callback) {
+        this.builder.having(callback);
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        this.builder.orderBy(this.mapColumn(column), direction);
+        return this;
+    }
+    limit(count) {
+        this.builder.limit(count);
+        return this;
+    }
+    offset(count) {
+        this.builder.offset(count);
+        return this;
+    }
+    toString() {
+        return this.builder.toString();
+    }
+    async all() {
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelect(sql, this.tableName);
+        const numericAliases = this.builder.getNumericAliases();
+        if (numericAliases.length > 0) {
+            for (const row of result.data) {
+                for (const alias of numericAliases) {
+                    if (alias in row && typeof row[alias] === 'string') {
+                        row[alias] = Number(row[alias]);
+                    }
+                }
+            }
+        }
+        return result.data;
+    }
+    async get() {
+        this.builder.limit(1);
+        const sql = this.builder.toString();
+        const result = await this.relq[methods_1.INTERNAL].executeSelectOne(sql, this.tableName);
+        const numericAliases = this.builder.getNumericAliases();
+        if (numericAliases.length > 0 && result.data) {
+            for (const alias of numericAliases) {
+                if (alias in result.data && typeof result.data[alias] === 'string') {
+                    result.data[alias] = Number(result.data[alias]);
+                }
+            }
+        }
+        return result.data;
+    }
+}
+exports.ConnectedAggregateBuilder = ConnectedAggregateBuilder;

package/dist/cjs/core/helpers/ConnectedCTEBuilder.cjs

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedCTEBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+class ConnectedCTEBuilder {
+    relq;
+    ctes = [];
+    constructor(relq) {
+        this.relq = relq;
+    }
+    with(name, query) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        this.ctes.push({ name, query: queryStr });
+        return this;
+    }
+    withMaterialized(name, query) {
+        const queryStr = typeof query === 'string' ? query : query.toString();
+        this.ctes.push({ name, query: `MATERIALIZED (${queryStr})` });
+        return this;
+    }
+    async query(sql) {
+        const cteClause = this.buildCTEClause();
+        const fullSql = `${cteClause} ${sql}`;
+        const result = await this.relq[methods_1.INTERNAL].executeQuery(fullSql);
+        return {
+            data: result.result.rows,
+            rowCount: result.result.rowCount ?? 0
+        };
+    }
+    async all(sql) {
+        const result = await this.query(sql);
+        return result.data;
+    }
+    async get(sql) {
+        const result = await this.query(sql);
+        return result.data[0] ?? null;
+    }
+    buildCTEClause() {
+        if (this.ctes.length === 0)
+            return '';
+        const cteStrings = this.ctes.map(cte => {
+            if (cte.query.startsWith('MATERIALIZED')) {
+                return `"${cte.name}" AS ${cte.query}`;
+            }
+            return `"${cte.name}" AS (${cte.query})`;
+        });
+        return `WITH ${cteStrings.join(', ')}`;
+    }
+    toSQL(mainQuery) {
+        return `${this.buildCTEClause()} ${mainQuery}`;
+    }
+}
+exports.ConnectedCTEBuilder = ConnectedCTEBuilder;

package/dist/cjs/core/helpers/ConnectedCountBuilder.cjs

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedCountBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+const table_accessor_1 = require("../shared/table-accessor.cjs");
+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 = (0, table_accessor_1.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[methods_1.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[methods_1.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;
+    }
+}
+exports.ConnectedCountBuilder = ConnectedCountBuilder;

package/dist/cjs/core/helpers/ConnectedDeleteBuilder.cjs

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedDeleteBuilder = void 0;
+const methods_1 = require("./methods.cjs");
+const ReturningExecutor_1 = require("./ReturningExecutor.cjs");
+const capability_guard_1 = require("./capability-guard.cjs");
+const table_accessor_1 = require("../shared/table-accessor.cjs");
+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[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;
+        });
+    }
+    where(callback) {
+        this.builder.where((q) => {
+            q._tables = (0, table_accessor_1.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[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 DELETE to retrieve deleted data');
+        this.builder.returning(columns);
+        return new ReturningExecutor_1.ReturningExecutor(this.builder, this.relq, this.tableName, this.schemaKey);
+    }
+}
+exports.ConnectedDeleteBuilder = ConnectedDeleteBuilder;