@relq/orm 0.1.0

package/dist/esm/condition/network-condition-builder.js

@@ -0,0 +1,229 @@
+import format from "../shared/pg-format.js";
+function networkToSQL(address) {
+    if (typeof address === 'string')
+        return address;
+    const { octets, mask } = address;
+    const ip = octets.join('.');
+    return mask !== undefined ? `${ip}/${mask}` : ip;
+}
+export class NetworkConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    containedByStrict(column, value) {
+        this.parent.conditions.push({
+            method: 'network_contained_by_strict',
+            column,
+            values: networkToSQL(value)
+        });
+        return this.parent;
+    }
+    containedByOrEqual(column, value) {
+        this.parent.conditions.push({
+            method: 'network_contained_by_or_equal',
+            column,
+            values: networkToSQL(value)
+        });
+        return this.parent;
+    }
+    containsStrict(column, value) {
+        this.parent.conditions.push({
+            method: 'network_contains_strict',
+            column,
+            values: networkToSQL(value)
+        });
+        return this.parent;
+    }
+    containsOrEqual(column, value) {
+        this.parent.conditions.push({
+            method: 'network_contains_or_equal',
+            column,
+            values: networkToSQL(value)
+        });
+        return this.parent;
+    }
+    overlaps(column, value) {
+        this.parent.conditions.push({
+            method: 'network_overlaps',
+            column,
+            values: networkToSQL(value)
+        });
+        return this.parent;
+    }
+    sameFamily(column, value) {
+        this.parent.conditions.push({
+            method: 'network_same_family',
+            column,
+            values: networkToSQL(value)
+        });
+        return this.parent;
+    }
+    isIPv4(column) {
+        this.parent.conditions.push({
+            method: 'network_is_ipv4',
+            column
+        });
+        return this.parent;
+    }
+    isIPv6(column) {
+        this.parent.conditions.push({
+            method: 'network_is_ipv6',
+            column
+        });
+        return this.parent;
+    }
+    maskLengthEquals(column, length) {
+        this.parent.conditions.push({
+            method: 'network_masklen_eq',
+            column,
+            values: length
+        });
+        return this.parent;
+    }
+    maskLengthGreaterThan(column, length) {
+        this.parent.conditions.push({
+            method: 'network_masklen_gt',
+            column,
+            values: length
+        });
+        return this.parent;
+    }
+    maskLengthLessThan(column, length) {
+        this.parent.conditions.push({
+            method: 'network_masklen_lt',
+            column,
+            values: length
+        });
+        return this.parent;
+    }
+    bitwiseAnd(column, mask, expected) {
+        this.parent.conditions.push({
+            method: 'network_bitwise_and',
+            column,
+            values: { mask, expected }
+        });
+        return this.parent;
+    }
+    bitwiseOr(column, value, expected) {
+        this.parent.conditions.push({
+            method: 'network_bitwise_or',
+            column,
+            values: { value, expected }
+        });
+        return this.parent;
+    }
+    macEquals(column, value) {
+        this.parent.conditions.push({
+            method: 'network_mac_equals',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    macNotEquals(column, value) {
+        this.parent.conditions.push({
+            method: 'network_mac_not_equals',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    macGreaterThan(column, value) {
+        this.parent.conditions.push({
+            method: 'network_mac_gt',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    macLessThan(column, value) {
+        this.parent.conditions.push({
+            method: 'network_mac_lt',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    macTruncEquals(column, oui) {
+        this.parent.conditions.push({
+            method: 'network_mac_trunc_equals',
+            column,
+            values: oui
+        });
+        return this.parent;
+    }
+    hostEquals(column, value) {
+        this.parent.conditions.push({
+            method: 'network_host_equals',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    networkEquals(column, value) {
+        this.parent.conditions.push({
+            method: 'network_network_equals',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    broadcastEquals(column, value) {
+        this.parent.conditions.push({
+            method: 'network_broadcast_equals',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+}
+export function buildNetworkConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'network_contained_by_strict':
+            return format('%I << inet %L', column, values);
+        case 'network_contained_by_or_equal':
+            return format('%I <<= inet %L', column, values);
+        case 'network_contains_strict':
+            return format('%I >> inet %L', column, values);
+        case 'network_contains_or_equal':
+            return format('%I >>= inet %L', column, values);
+        case 'network_overlaps':
+            return format('%I && inet %L', column, values);
+        case 'network_same_family':
+            return format('inet_same_family(%I, inet %L)', column, values);
+        case 'network_is_ipv4':
+            return format('family(%I) = 4', column);
+        case 'network_is_ipv6':
+            return format('family(%I) = 6', column);
+        case 'network_masklen_eq':
+            return format('masklen(%I) = %s', column, values);
+        case 'network_masklen_gt':
+            return format('masklen(%I) > %s', column, values);
+        case 'network_masklen_lt':
+            return format('masklen(%I) < %s', column, values);
+        case 'network_bitwise_and':
+            return format('(%I & inet %L) = inet %L', column, values.mask, values.expected);
+        case 'network_bitwise_or':
+            return format('(%I | inet %L) = inet %L', column, values.value, values.expected);
+        case 'network_mac_equals':
+            return format('%I = macaddr %L', column, values);
+        case 'network_mac_not_equals':
+            return format('%I <> macaddr %L', column, values);
+        case 'network_mac_gt':
+            return format('%I > macaddr %L', column, values);
+        case 'network_mac_lt':
+            return format('%I < macaddr %L', column, values);
+        case 'network_mac_trunc_equals':
+            return format('trunc(%I) = macaddr %L', column, values);
+        case 'network_host_equals':
+            return format('host(%I) = %L', column, values);
+        case 'network_network_equals':
+            return format('network(%I) = cidr %L', column, values);
+        case 'network_broadcast_equals':
+            return format('broadcast(%I) = inet %L', column, values);
+        default:
+            return '';
+    }
+}

package/dist/esm/condition/postgis-condition-builder.js

@@ -0,0 +1,180 @@
+import format from "../shared/pg-format.js";
+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 };
+}
+export 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;
+    }
+}
+function formatGeometrySQL(geometry, isGeoJson) {
+    if (isGeoJson) {
+        return format('ST_GeomFromGeoJSON(%L)', geometry);
+    }
+    return format('ST_GeomFromText(%L)', geometry);
+}
+export function buildPostgisConditionSQL(condition) {
+    const { method, column, values } = condition;
+    const { geometry, isGeoJson } = values;
+    const geomSQL = formatGeometrySQL(geometry, isGeoJson);
+    switch (method) {
+        case 'postgis_contains':
+            return format('ST_Contains(%I, ', column) + geomSQL + ')';
+        case 'postgis_within':
+            return format('ST_Within(%I, ', column) + geomSQL + ')';
+        case 'postgis_intersects':
+            return format('ST_Intersects(%I, ', column) + geomSQL + ')';
+        case 'postgis_overlaps':
+            return format('ST_Overlaps(%I, ', column) + geomSQL + ')';
+        case 'postgis_crosses':
+            return format('ST_Crosses(%I, ', column) + geomSQL + ')';
+        case 'postgis_touches':
+            return format('ST_Touches(%I, ', column) + geomSQL + ')';
+        case 'postgis_disjoint':
+            return format('ST_Disjoint(%I, ', column) + geomSQL + ')';
+        case 'postgis_equals':
+            return format('ST_Equals(%I, ', column) + geomSQL + ')';
+        case 'postgis_dwithin': {
+            const { distance } = values;
+            return format('ST_DWithin(%I, ', column) + geomSQL + format(', %s)', distance);
+        }
+        case 'postgis_distance_lt': {
+            const { distance } = values;
+            return format('ST_Distance(%I, ', column) + geomSQL + format(') < %s', distance);
+        }
+        case 'postgis_distance_gt': {
+            const { distance } = values;
+            return format('ST_Distance(%I, ', column) + geomSQL + format(') > %s', distance);
+        }
+        case 'postgis_covered_by':
+            return format('ST_CoveredBy(%I, ', column) + geomSQL + ')';
+        case 'postgis_covers':
+            return format('ST_Covers(%I, ', column) + geomSQL + ')';
+        default:
+            return '';
+    }
+}

package/dist/esm/condition/range-condition-builder.js

@@ -0,0 +1,90 @@
+import format from "../shared/pg-format.js";
+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}`;
+}
+export 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;
+    }
+}
+export function buildRangeConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'range_contains':
+            return format('%I @> %L', column, values);
+        case 'range_contained_by':
+            return format('%I <@ %L', column, values);
+        case 'range_overlaps':
+            return format('%I && %L', column, values);
+        case 'range_strictly_left':
+            return format('%I << %L', column, values);
+        case 'range_strictly_right':
+            return format('%I >> %L', column, values);
+        case 'range_adjacent':
+            return format('%I -|- %L', column, values);
+        default:
+            return '';
+    }
+}

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

@@ -0,0 +1,128 @@
+import { INTERNAL } from "./methods.js";
+import { createTableAccessor } from "../shared/table-accessor.js";
+export class ConnectedAggregateBuilder {
+    builder;
+    relq;
+    tableName;
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    mapColumn(column) {
+        const transformed = this.relq[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 = 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[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[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;
+    }
+}

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

@@ -0,0 +1,49 @@
+import { INTERNAL } from "./methods.js";
+export 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[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}`;
+    }
+}