@relq/orm 0.1.3 → 0.1.5

package/dist/esm/pg/condition/json-path-proxy.js

@@ -0,0 +1,473 @@
+import format from "../../shared/pg-format.js";
+const TERMINAL_METHODS = new Set([
+    'equal', 'notEqual',
+    'greaterThan', 'greaterThanOrEqual',
+    'lessThan', 'lessThanOrEqual',
+    'between',
+    'in', 'notIn',
+    'like', 'ilike',
+    'startsWith', 'endsWith',
+    'contains',
+    'regex', 'iregex',
+    'before', 'after',
+    'isNull', 'isNotNull',
+    'containedBy',
+    'hasKey', 'hasAnyKeys', 'hasAllKeys',
+    'typeOf',
+]);
+const ARRAY_TERMINAL_METHODS = new Set([
+    'length', 'isEmpty', 'isNotEmpty',
+    'contains', 'containsAll', 'containsAny',
+    'some', 'every',
+]);
+const ELEMENT_TERMINALS = new Set([
+    'equal', 'notEqual',
+    'isNull', 'isNotNull',
+    'in', 'notIn',
+    'greaterThan', 'greaterThanOrEqual',
+    'lessThan', 'lessThanOrEqual',
+    'between',
+    'like', 'ilike', 'startsWith', 'endsWith',
+    'contains',
+    'regex', 'iregex',
+    'before', 'after',
+    'containedBy',
+    'hasKey', 'hasAnyKeys', 'hasAllKeys',
+    'typeOf',
+]);
+const PROXY_TRAP_IGNORE = new Set([
+    'then', 'toJSON', 'valueOf', 'toString',
+    'constructor', 'prototype', '__proto__',
+    'inspect', 'nodeType',
+    'asymmetricMatch',
+    '$$typeof',
+]);
+export function createJsonColumnProxy(parent) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            return createJsonPathProxy(prop, [], parent);
+        }
+    });
+}
+function createJsonPathProxy(column, path, parent) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            const propName = prop;
+            if (TERMINAL_METHODS.has(propName)) {
+                return (...args) => {
+                    parent.conditions.push({
+                        method: 'json_proxy',
+                        column,
+                        values: { path: [...path], op: propName, args }
+                    });
+                    return parent;
+                };
+            }
+            if (propName === 'array') {
+                return createJsonArrayProxy(column, path, parent);
+            }
+            return createJsonPathProxy(column, [...path, propName], parent);
+        }
+    });
+}
+function createJsonArrayProxy(column, path, parent) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            const propName = prop;
+            if (propName === 'some') {
+                return (callback) => {
+                    const subConditions = [];
+                    const elementProxy = createJsonArrayElementProxy(subConditions);
+                    callback(elementProxy);
+                    parent.conditions.push({
+                        method: 'json_proxy',
+                        column,
+                        values: { path: [...path], op: 'array_some', args: [{ conditions: subConditions }] }
+                    });
+                    return parent;
+                };
+            }
+            if (propName === 'every') {
+                return (callback) => {
+                    const subConditions = [];
+                    const elementProxy = createJsonArrayElementProxy(subConditions);
+                    callback(elementProxy);
+                    parent.conditions.push({
+                        method: 'json_proxy',
+                        column,
+                        values: { path: [...path], op: 'array_every', args: [{ conditions: subConditions }] }
+                    });
+                    return parent;
+                };
+            }
+            if (ARRAY_TERMINAL_METHODS.has(propName)) {
+                return (...args) => {
+                    parent.conditions.push({
+                        method: 'json_proxy',
+                        column,
+                        values: { path: [...path], op: `array_${propName}`, args }
+                    });
+                    return parent;
+                };
+            }
+            return undefined;
+        }
+    });
+}
+function createJsonArrayElementProxy(conditions, path = []) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            const name = prop;
+            if (ELEMENT_TERMINALS.has(name)) {
+                return (...args) => {
+                    conditions.push({ path: [...path], op: name, args });
+                };
+            }
+            return createJsonArrayElementProxy(conditions, [...path, name]);
+        }
+    });
+}
+export function buildPgJsonProxySQL(condition) {
+    const { column, values } = condition;
+    const { path, op, args } = values;
+    if (!column)
+        return '';
+    if (op.startsWith('array_')) {
+        return buildPgArrayOpSQL(column, path, op, args);
+    }
+    if (path.length === 0) {
+        return buildPgColumnLevelSQL(column, op, args);
+    }
+    return buildPgPathLevelSQL(column, path, op, args);
+}
+function buildPgColumnLevelSQL(column, op, args) {
+    switch (op) {
+        case 'contains':
+            return format('%I @> %L', column, JSON.stringify(args[0]));
+        case 'containedBy':
+            return format('%I <@ %L', column, JSON.stringify(args[0]));
+        case 'hasKey':
+            return format('%I ? %L', column, args[0]);
+        case 'hasAnyKeys':
+            return format('%I ?| ARRAY[%s]', column, args[0].map(k => format('%L', k)).join(','));
+        case 'hasAllKeys':
+            return format('%I ?& ARRAY[%s]', column, args[0].map(k => format('%L', k)).join(','));
+        case 'isNull':
+            return format('%I IS NULL', column);
+        case 'isNotNull':
+            return format('%I IS NOT NULL', column);
+        case 'equal':
+            return format('%I = %L::jsonb', column, JSON.stringify(args[0]));
+        case 'notEqual':
+            return format('%I != %L::jsonb', column, JSON.stringify(args[0]));
+        case 'typeOf':
+            return format('jsonb_typeof(%I) = %L', column, args[0]);
+        default:
+            return '';
+    }
+}
+function buildPgPathLevelSQL(column, path, op, args) {
+    const pathStr = `{${path.join(',')}}`;
+    switch (op) {
+        case 'equal':
+            return format('%I#>>%L = %L', column, pathStr, String(args[0]));
+        case 'notEqual':
+            return format('%I#>>%L != %L', column, pathStr, String(args[0]));
+        case 'greaterThan':
+            return typeof args[0] === 'number'
+                ? format('(%I#>>%L)::numeric > %L', column, pathStr, args[0])
+                : format('%I#>>%L > %L', column, pathStr, args[0]);
+        case 'greaterThanOrEqual':
+            return typeof args[0] === 'number'
+                ? format('(%I#>>%L)::numeric >= %L', column, pathStr, args[0])
+                : format('%I#>>%L >= %L', column, pathStr, args[0]);
+        case 'lessThan':
+            return typeof args[0] === 'number'
+                ? format('(%I#>>%L)::numeric < %L', column, pathStr, args[0])
+                : format('%I#>>%L < %L', column, pathStr, args[0]);
+        case 'lessThanOrEqual':
+            return typeof args[0] === 'number'
+                ? format('(%I#>>%L)::numeric <= %L', column, pathStr, args[0])
+                : format('%I#>>%L <= %L', column, pathStr, args[0]);
+        case 'between':
+            return typeof args[0] === 'number'
+                ? format('(%I#>>%L)::numeric BETWEEN %L AND %L', column, pathStr, args[0], args[1])
+                : format('%I#>>%L BETWEEN %L AND %L', column, pathStr, args[0], args[1]);
+        case 'in': {
+            const inList = args[0].map(v => format('%L', v)).join(', ');
+            return format('%I#>>%L IN (%s)', column, pathStr, inList);
+        }
+        case 'notIn': {
+            const notInList = args[0].map(v => format('%L', v)).join(', ');
+            return format('%I#>>%L NOT IN (%s)', column, pathStr, notInList);
+        }
+        case 'like':
+            return format('%I#>>%L LIKE %L', column, pathStr, args[0]);
+        case 'ilike':
+            return format('%I#>>%L ILIKE %L', column, pathStr, args[0]);
+        case 'startsWith':
+            return format('%I#>>%L LIKE %L', column, pathStr, `${args[0]}%`);
+        case 'endsWith':
+            return format('%I#>>%L LIKE %L', column, pathStr, `%${args[0]}`);
+        case 'contains':
+            if (typeof args[0] === 'string') {
+                return format('%I#>>%L LIKE %L', column, pathStr, `%${args[0]}%`);
+            }
+            return format('%I#>%L @> %L', column, pathStr, JSON.stringify(args[0]));
+        case 'regex':
+            return format('%I#>>%L ~ %L', column, pathStr, args[0]);
+        case 'iregex':
+            return format('%I#>>%L ~* %L', column, pathStr, args[0]);
+        case 'before':
+            return format('%I#>>%L < %L', column, pathStr, args[0] instanceof Date ? args[0].toISOString() : args[0]);
+        case 'after':
+            return format('%I#>>%L > %L', column, pathStr, args[0] instanceof Date ? args[0].toISOString() : args[0]);
+        case 'isNull':
+            return format('(%I#>%L IS NULL OR %I#>%L = \'null\'::jsonb)', column, pathStr, column, pathStr);
+        case 'isNotNull':
+            return format('(%I#>%L IS NOT NULL AND %I#>%L != \'null\'::jsonb)', column, pathStr, column, pathStr);
+        case 'containedBy':
+            return format('%I#>%L <@ %L', column, pathStr, JSON.stringify(args[0]));
+        case 'hasKey':
+            return format('%I#>%L ? %L', column, pathStr, args[0]);
+        case 'hasAnyKeys':
+            return format('%I#>%L ?| ARRAY[%s]', column, pathStr, args[0].map(k => format('%L', k)).join(','));
+        case 'hasAllKeys':
+            return format('%I#>%L ?& ARRAY[%s]', column, pathStr, args[0].map(k => format('%L', k)).join(','));
+        case 'typeOf':
+            return format('jsonb_typeof(%I#>%L) = %L', column, pathStr, args[0]);
+        default:
+            return '';
+    }
+}
+function buildPgArrayOpSQL(column, path, op, args) {
+    const source = path.length === 0
+        ? format('COALESCE(%I, \'[]\'::jsonb)', column)
+        : format('COALESCE(%I#>%L, \'[]\'::jsonb)', column, `{${path.join(',')}}`);
+    switch (op) {
+        case 'array_length': {
+            const [operator, value] = args;
+            return `jsonb_array_length(${source}) ${operator} ${value}`;
+        }
+        case 'array_isEmpty':
+            return `jsonb_array_length(${source}) = 0`;
+        case 'array_isNotEmpty':
+            return `jsonb_array_length(${source}) > 0`;
+        case 'array_contains': {
+            const colExpr = path.length === 0
+                ? format.ident(column)
+                : format('%I#>%L', column, `{${path.join(',')}}`);
+            return `${colExpr} @> ${format('%L', JSON.stringify([args[0]]))}`;
+        }
+        case 'array_containsAll': {
+            const colExpr = path.length === 0
+                ? format.ident(column)
+                : format('%I#>%L', column, `{${path.join(',')}}`);
+            return `${colExpr} @> ${format('%L', JSON.stringify(args[0]))}`;
+        }
+        case 'array_containsAny': {
+            const colExpr = path.length === 0
+                ? format.ident(column)
+                : format('%I#>%L', column, `{${path.join(',')}}`);
+            const elements = args[0];
+            const conditions = elements.map(el => `${colExpr} @> ${format('%L', JSON.stringify([el]))}`);
+            return `(${conditions.join(' OR ')})`;
+        }
+        case 'array_some': {
+            const { conditions } = args[0];
+            return buildJsonArrayQuantifiedSQL(source, conditions, 'some');
+        }
+        case 'array_every': {
+            const { conditions } = args[0];
+            return buildJsonArrayQuantifiedSQL(source, conditions, 'every');
+        }
+        default:
+            return '';
+    }
+}
+function buildJsonArrayQuantifiedSQL(source, conditions, quantifier) {
+    if (conditions.length === 0)
+        return '';
+    const whereClauses = conditions.map(cond => buildJsonElementSQL(cond));
+    const validClauses = whereClauses.filter(Boolean);
+    if (validClauses.length === 0)
+        return '';
+    const whereClause = validClauses.join(' AND ');
+    if (quantifier === 'some') {
+        return `EXISTS (SELECT 1 FROM jsonb_array_elements(${source}) elem WHERE ${whereClause})`;
+    }
+    return `NOT EXISTS (SELECT 1 FROM jsonb_array_elements(${source}) elem WHERE NOT (${whereClause}))`;
+}
+function buildJsonElementSQL(cond) {
+    const { path, op, args } = cond;
+    if (path.length === 0) {
+        return buildJsonScalarElementSQL(op, args);
+    }
+    return buildJsonNestedElementSQL(path, op, args);
+}
+function buildJsonScalarElementSQL(op, args) {
+    const elemText = "elem #>> '{}'";
+    const elemJsonb = 'elem';
+    switch (op) {
+        case 'equal':
+            return typeof args[0] === 'boolean'
+                ? `${elemText} = ${format('%L', String(args[0]))}`
+                : typeof args[0] === 'number'
+                    ? `(${elemText})::numeric = ${format('%L', args[0])}`
+                    : `${elemText} = ${format('%L', args[0])}`;
+        case 'notEqual':
+            return typeof args[0] === 'number'
+                ? `(${elemText})::numeric != ${format('%L', args[0])}`
+                : `${elemText} != ${format('%L', args[0])}`;
+        case 'greaterThan':
+            return `(${elemText})::numeric > ${format('%L', args[0])}`;
+        case 'greaterThanOrEqual':
+            return `(${elemText})::numeric >= ${format('%L', args[0])}`;
+        case 'lessThan':
+            return `(${elemText})::numeric < ${format('%L', args[0])}`;
+        case 'lessThanOrEqual':
+            return `(${elemText})::numeric <= ${format('%L', args[0])}`;
+        case 'between':
+            return typeof args[0] === 'number'
+                ? `(${elemText})::numeric BETWEEN ${format('%L', args[0])} AND ${format('%L', args[1])}`
+                : `${elemText} BETWEEN ${format('%L', args[0])} AND ${format('%L', args[1])}`;
+        case 'in': {
+            const vals = args[0].map(v => format('%L', v)).join(', ');
+            return `${elemText} IN (${vals})`;
+        }
+        case 'notIn': {
+            const vals = args[0].map(v => format('%L', v)).join(', ');
+            return `${elemText} NOT IN (${vals})`;
+        }
+        case 'like':
+            return `${elemText} LIKE ${format('%L', args[0])}`;
+        case 'ilike':
+            return `${elemText} ILIKE ${format('%L', args[0])}`;
+        case 'startsWith':
+            return `${elemText} LIKE ${format('%L', `${args[0]}%`)}`;
+        case 'endsWith':
+            return `${elemText} LIKE ${format('%L', `%${args[0]}`)}`;
+        case 'contains':
+            if (typeof args[0] === 'string') {
+                return `${elemText} LIKE ${format('%L', `%${args[0]}%`)}`;
+            }
+            return `${elemJsonb} @> ${format('%L', JSON.stringify(args[0]))}`;
+        case 'regex':
+            return `${elemText} ~ ${format('%L', args[0])}`;
+        case 'iregex':
+            return `${elemText} ~* ${format('%L', args[0])}`;
+        case 'before':
+            return `${elemText} < ${format('%L', args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'after':
+            return `${elemText} > ${format('%L', args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'isNull':
+            return `(${elemJsonb} IS NULL OR ${elemJsonb} = 'null'::jsonb)`;
+        case 'isNotNull':
+            return `(${elemJsonb} IS NOT NULL AND ${elemJsonb} != 'null'::jsonb)`;
+        case 'containedBy':
+            return `${elemJsonb} <@ ${format('%L', JSON.stringify(args[0]))}`;
+        case 'hasKey':
+            return `${elemJsonb} ? ${format('%L', args[0])}`;
+        case 'hasAnyKeys':
+            return `${elemJsonb} ?| ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'hasAllKeys':
+            return `${elemJsonb} ?& ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'typeOf':
+            return `jsonb_typeof(${elemJsonb}) = ${format('%L', args[0])}`;
+        default:
+            return '';
+    }
+}
+function buildJsonNestedElementSQL(path, op, args) {
+    const elemText = path.length === 1
+        ? `elem->>${format('%L', path[0])}`
+        : `elem#>>'{${path.join(',')}}'`;
+    const elemJsonb = path.length === 1
+        ? `elem->${format('%L', path[0])}`
+        : `elem#>'{${path.join(',')}}'`;
+    switch (op) {
+        case 'equal':
+            return typeof args[0] === 'boolean'
+                ? `${elemText} = ${format('%L', String(args[0]))}`
+                : typeof args[0] === 'number'
+                    ? `(${elemText})::numeric = ${format('%L', args[0])}`
+                    : typeof args[0] === 'object' && args[0] !== null
+                        ? `${elemJsonb} = ${format('%L', JSON.stringify(args[0]))}::jsonb`
+                        : `${elemText} = ${format('%L', args[0])}`;
+        case 'notEqual':
+            return typeof args[0] === 'number'
+                ? `(${elemText})::numeric != ${format('%L', args[0])}`
+                : typeof args[0] === 'object' && args[0] !== null
+                    ? `${elemJsonb} != ${format('%L', JSON.stringify(args[0]))}::jsonb`
+                    : `${elemText} != ${format('%L', args[0])}`;
+        case 'greaterThan':
+            return `(${elemText})::numeric > ${format('%L', args[0])}`;
+        case 'greaterThanOrEqual':
+            return `(${elemText})::numeric >= ${format('%L', args[0])}`;
+        case 'lessThan':
+            return `(${elemText})::numeric < ${format('%L', args[0])}`;
+        case 'lessThanOrEqual':
+            return `(${elemText})::numeric <= ${format('%L', args[0])}`;
+        case 'between':
+            return typeof args[0] === 'number'
+                ? `(${elemText})::numeric BETWEEN ${format('%L', args[0])} AND ${format('%L', args[1])}`
+                : `${elemText} BETWEEN ${format('%L', args[0])} AND ${format('%L', args[1])}`;
+        case 'in': {
+            const vals = args[0].map(v => format('%L', v)).join(', ');
+            return `${elemText} IN (${vals})`;
+        }
+        case 'notIn': {
+            const vals = args[0].map(v => format('%L', v)).join(', ');
+            return `${elemText} NOT IN (${vals})`;
+        }
+        case 'like':
+            return `${elemText} LIKE ${format('%L', args[0])}`;
+        case 'ilike':
+            return `${elemText} ILIKE ${format('%L', args[0])}`;
+        case 'startsWith':
+            return `${elemText} LIKE ${format('%L', `${args[0]}%`)}`;
+        case 'endsWith':
+            return `${elemText} LIKE ${format('%L', `%${args[0]}`)}`;
+        case 'contains':
+            if (typeof args[0] === 'string') {
+                return `${elemText} LIKE ${format('%L', `%${args[0]}%`)}`;
+            }
+            return `${elemJsonb} @> ${format('%L', JSON.stringify(args[0]))}`;
+        case 'regex':
+            return `${elemText} ~ ${format('%L', args[0])}`;
+        case 'iregex':
+            return `${elemText} ~* ${format('%L', args[0])}`;
+        case 'before':
+            return `${elemText} < ${format('%L', args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'after':
+            return `${elemText} > ${format('%L', args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'isNull':
+            return `(${elemJsonb} IS NULL OR ${elemJsonb} = 'null'::jsonb)`;
+        case 'isNotNull':
+            return `(${elemJsonb} IS NOT NULL AND ${elemJsonb} != 'null'::jsonb)`;
+        case 'containedBy':
+            return `${elemJsonb} <@ ${format('%L', JSON.stringify(args[0]))}`;
+        case 'hasKey':
+            return `${elemJsonb} ? ${format('%L', args[0])}`;
+        case 'hasAnyKeys':
+            return `${elemJsonb} ?| ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'hasAllKeys':
+            return `${elemJsonb} ?& ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'typeOf':
+            return `jsonb_typeof(${elemJsonb}) = ${format('%L', args[0])}`;
+        default:
+            return '';
+    }
+}

package/dist/esm/{condition → pg/condition}/jsonb-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 export class JsonbArrayConditionBuilder {
     parent;
     constructor(parent) {

package/dist/esm/{condition → pg/condition}/network-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 function networkToSQL(address) {
     if (typeof address === 'string')
         return address;

package/dist/esm/{condition → pg/condition}/postgis-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 function isGeoJson(input) {
     return typeof input === 'object' && input !== null && 'type' in input && 'coordinates' in input;
 }

package/dist/esm/{condition → pg/condition}/range-condition-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 function rangeToSQL(range) {
     if (typeof range === 'string')
         return range;

package/dist/esm/{count → pg/count}/count-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { ConditionCollector, buildConditionsSQL, buildConditionSQL } from "../condition/condition-collector.js";
 export class CountBuilder {
     tableName;
@@ -42,10 +42,15 @@ export class CountBuilder {
         });
         return this;
     }
-    where(callback) {
-        const conditionBuilder = new ConditionCollector();
-        callback(conditionBuilder);
-        this.whereConditions.push(...conditionBuilder.getConditions());
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof ConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new ConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
         return this;
     }
     toString() {

package/dist/esm/{delete → pg/delete}/delete-builder.js

@@ -1,4 +1,4 @@
-import format from "../shared/pg-format.js";
+import format from "../../shared/pg-format.js";
 import { ConditionCollector, buildConditionsSQL } from "../condition/condition-collector.js";
 import { SelectBuilder } from "../select/select-builder.js";
 import { CountBuilder } from "../count/count-builder.js";
@@ -47,10 +47,15 @@ export class DeleteBuilder {
             };
         });
     }
-    where(callback) {
-        const conditionBuilder = new ConditionCollector();
-        callback(conditionBuilder);
-        this.whereConditions.push(...conditionBuilder.getConditions());
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof ConditionCollector) {
+            this.whereConditions.push(...callbackOrCondition.getConditions());
+        }
+        else {
+            const conditionBuilder = new ConditionCollector();
+            callbackOrCondition(conditionBuilder);
+            this.whereConditions.push(...conditionBuilder.getConditions());
+        }
         return this;
     }
     returning(columns) {

package/dist/esm/{core → pg}/helpers/ConnectedAggregateBuilder.js

@@ -1,5 +1,7 @@
-import { INTERNAL } from "./methods.js";
-import { createTableAccessor } from "../shared/table-accessor.js";
+import { ConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { createTableAccessor } from "../../core/shared/table-accessor.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
 export class ConnectedAggregateBuilder {
     builder;
     relq;
@@ -9,6 +11,7 @@ export class ConnectedAggregateBuilder {
         this.relq = relq;
         this.tableName = tableName;
     }
+    get _sourceTableKey() { return this.tableName; }
     mapColumn(column) {
         const transformed = this.relq[INTERNAL].transformToDbColumns(this.tableName, { [column]: true });
         return Object.keys(transformed)[0] || column;
@@ -70,7 +73,17 @@ export class ConnectedAggregateBuilder {
         this.builder.boolOr(this.mapColumn(column), alias);
         return this;
     }
-    where(callback) {
+    where(callbackOrCondition) {
+        if (callbackOrCondition instanceof ConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable && conditionTable !== this.tableName) {
+                throw new RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${this.tableName}'. ` +
+                    `Create the condition with db.where('${this.tableName}') instead.`);
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
         this.builder.where((q) => {
             q._tables = createTableAccessor(this.relq, this.relq.schema);
             return callback(q);

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

@@ -0,0 +1,82 @@
+import { ConditionCollector } from "../condition/condition-collector.js";
+import { INTERNAL } from "../../core/helpers/methods.js";
+import { createTableAccessor } from "../../core/shared/table-accessor.js";
+import { RelqBuilderError } from "../../shared/errors/relq-errors.js";
+export class ConnectedCountBuilder {
+    builder;
+    relq;
+    tableName;
+    groupNames = [];
+    constructor(builder, relq, tableName) {
+        this.builder = builder;
+        this.relq = relq;
+        this.tableName = tableName;
+    }
+    get _sourceTableKey() { return this.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(callbackOrCondition) {
+        if (callbackOrCondition instanceof ConditionCollector) {
+            const conditionTable = callbackOrCondition._tableName;
+            if (conditionTable && conditionTable !== this.tableName) {
+                throw new RelqBuilderError(`Condition was created for table '${conditionTable}' but is being used on '${this.tableName}'. ` +
+                    `Create the condition with db.where('${this.tableName}') instead.`);
+            }
+            this.builder.where(callbackOrCondition);
+            return this;
+        }
+        const callback = callbackOrCondition;
+        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;
+    }
+}