@relq/orm 0.1.3 → 0.1.5

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

@@ -0,0 +1,372 @@
+import format from "../../shared/pg-format.js";
+const PROXY_TRAP_IGNORE = new Set([
+    'then', 'toJSON', 'valueOf', 'toString',
+    'constructor', 'prototype', '__proto__',
+    'inspect', 'nodeType',
+    'asymmetricMatch', '$$typeof',
+]);
+const ELEMENT_TERMINALS = new Set([
+    'equal', 'notEqual', 'in', 'notIn',
+    'isNull', 'isNotNull',
+    'greaterThan', 'greaterThanOrEqual',
+    'lessThan', 'lessThanOrEqual',
+    'between',
+    'like', 'ilike', 'startsWith', 'endsWith',
+    'contains',
+    'regex', 'iregex',
+    'before', 'after',
+    'containedBy',
+    'hasKey', 'hasAnyKeys', 'hasAllKeys',
+    'typeOf',
+]);
+export function createArrayColumnProxy(parent) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            return createArrayProxy(prop, parent);
+        }
+    });
+}
+function createArrayProxy(column, parent) {
+    return new Proxy(Object.create(null), {
+        get(_target, prop) {
+            if (typeof prop === 'symbol' || PROXY_TRAP_IGNORE.has(prop)) {
+                return undefined;
+            }
+            const name = prop;
+            if (name === 'isEmpty') {
+                return () => {
+                    parent.conditions.push({ method: 'array_proxy_is_empty', column, values: null });
+                    return parent;
+                };
+            }
+            if (name === 'isNotEmpty') {
+                return () => {
+                    parent.conditions.push({ method: 'array_proxy_is_not_empty', column, values: null });
+                    return parent;
+                };
+            }
+            if (name === 'hasLength') {
+                return (length) => {
+                    parent.conditions.push({ method: 'array_proxy_has_length', column, values: length });
+                    return parent;
+                };
+            }
+            if (name === 'contains') {
+                return (values) => {
+                    parent.conditions.push({ method: 'array_proxy_contains', column, values });
+                    return parent;
+                };
+            }
+            if (name === 'containedBy') {
+                return (values) => {
+                    parent.conditions.push({ method: 'array_proxy_contained_by', column, values });
+                    return parent;
+                };
+            }
+            if (name === 'overlaps') {
+                return (values) => {
+                    parent.conditions.push({ method: 'array_proxy_overlaps', column, values });
+                    return parent;
+                };
+            }
+            if (name === 'equal') {
+                return (values) => {
+                    parent.conditions.push({ method: 'array_proxy_equal', column, values });
+                    return parent;
+                };
+            }
+            if (name === 'notEqual') {
+                return (values) => {
+                    parent.conditions.push({ method: 'array_proxy_not_equal', column, values });
+                    return parent;
+                };
+            }
+            if (name === 'some') {
+                return (callback) => {
+                    const subConditions = [];
+                    const elementProxy = createElementProxy(subConditions);
+                    callback(elementProxy);
+                    parent.conditions.push({
+                        method: 'array_proxy_some',
+                        column,
+                        values: { conditions: subConditions }
+                    });
+                    return parent;
+                };
+            }
+            if (name === 'every') {
+                return (callback) => {
+                    const subConditions = [];
+                    const elementProxy = createElementProxy(subConditions);
+                    callback(elementProxy);
+                    parent.conditions.push({
+                        method: 'array_proxy_every',
+                        column,
+                        values: { conditions: subConditions }
+                    });
+                    return parent;
+                };
+            }
+            return undefined;
+        }
+    });
+}
+function createElementProxy(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 createElementProxy(conditions, [...path, name]);
+        }
+    });
+}
+export function buildPgArrayProxySQL(condition) {
+    const { method, column, values } = condition;
+    if (!column)
+        return '';
+    switch (method) {
+        case 'array_proxy_is_empty':
+            return format('array_length(%I, 1) IS NULL', column);
+        case 'array_proxy_is_not_empty':
+            return format('array_length(%I, 1) > 0', column);
+        case 'array_proxy_has_length':
+            return format('array_length(%I, 1) = %s', column, values);
+        case 'array_proxy_contains':
+            return format('%I @> ARRAY[%s]', column, values.map(v => typeof v === 'object' ? format('%L::jsonb', JSON.stringify(v)) : format('%L', v)).join(','));
+        case 'array_proxy_contained_by':
+            return format('%I <@ ARRAY[%s]', column, values.map(v => typeof v === 'object' ? format('%L::jsonb', JSON.stringify(v)) : format('%L', v)).join(','));
+        case 'array_proxy_overlaps':
+            return format('%I && ARRAY[%s]', column, values.map(v => format('%L', v)).join(','));
+        case 'array_proxy_equal':
+            return format('%I = ARRAY[%s]', column, values.map(v => format('%L', v)).join(','));
+        case 'array_proxy_not_equal':
+            return format('%I <> ARRAY[%s]', column, values.map(v => format('%L', v)).join(','));
+        case 'array_proxy_some': {
+            const { conditions } = values;
+            return buildQuantifiedSQL(column, conditions, 'some');
+        }
+        case 'array_proxy_every': {
+            const { conditions } = values;
+            return buildQuantifiedSQL(column, conditions, 'every');
+        }
+        default:
+            return '';
+    }
+}
+function buildQuantifiedSQL(column, conditions, quantifier) {
+    if (conditions.length === 0)
+        return '';
+    const JSONB_ROOT_OPS = new Set([
+        'containedBy', 'hasKey', 'hasAnyKeys', 'hasAllKeys', 'typeOf',
+    ]);
+    const isJsonbArray = conditions.some(c => c.path.length > 0 || JSONB_ROOT_OPS.has(c.op) ||
+        (c.op === 'contains' && typeof c.args[0] === 'object' && c.args[0] !== null));
+    const conditionParts = conditions.map(c => isJsonbArray ? buildJsonbElementSQL(c) : buildScalarElementSQL(c));
+    const whereClause = conditionParts.filter(Boolean).join(' AND ');
+    if (!whereClause)
+        return '';
+    const col = format.ident(column);
+    if (isJsonbArray) {
+        if (quantifier === 'some') {
+            return `EXISTS (SELECT 1 FROM jsonb_array_elements(${col}) AS elem WHERE ${whereClause})`;
+        }
+        return `NOT EXISTS (SELECT 1 FROM jsonb_array_elements(${col}) AS elem WHERE NOT (${whereClause}))`;
+    }
+    if (quantifier === 'some') {
+        return `EXISTS (SELECT 1 FROM unnest(${col}) AS elem WHERE ${whereClause})`;
+    }
+    return `NOT EXISTS (SELECT 1 FROM unnest(${col}) AS elem WHERE NOT (${whereClause}))`;
+}
+function buildScalarElementSQL(condition) {
+    const { op, args } = condition;
+    switch (op) {
+        case 'equal':
+            return `elem = ${format('%L', args[0])}`;
+        case 'notEqual':
+            return `elem != ${format('%L', args[0])}`;
+        case 'greaterThan':
+            return typeof args[0] === 'number'
+                ? `elem > ${args[0]}`
+                : `elem > ${format('%L', args[0])}`;
+        case 'greaterThanOrEqual':
+            return typeof args[0] === 'number'
+                ? `elem >= ${args[0]}`
+                : `elem >= ${format('%L', args[0])}`;
+        case 'lessThan':
+            return typeof args[0] === 'number'
+                ? `elem < ${args[0]}`
+                : `elem < ${format('%L', args[0])}`;
+        case 'lessThanOrEqual':
+            return typeof args[0] === 'number'
+                ? `elem <= ${args[0]}`
+                : `elem <= ${format('%L', args[0])}`;
+        case 'between':
+            return typeof args[0] === 'number'
+                ? `elem BETWEEN ${args[0]} AND ${args[1]}`
+                : `elem BETWEEN ${format('%L', args[0])} AND ${format('%L', args[1])}`;
+        case 'in': {
+            const inList = args[0].map(v => format('%L', v)).join(', ');
+            return `elem IN (${inList})`;
+        }
+        case 'notIn': {
+            const notInList = args[0].map(v => format('%L', v)).join(', ');
+            return `elem NOT IN (${notInList})`;
+        }
+        case 'like':
+            return `elem LIKE ${format('%L', args[0])}`;
+        case 'ilike':
+            return `elem ILIKE ${format('%L', args[0])}`;
+        case 'startsWith':
+            return `elem LIKE ${format('%L', `${args[0]}%`)}`;
+        case 'endsWith':
+            return `elem LIKE ${format('%L', `%${args[0]}`)}`;
+        case 'contains':
+            return `elem LIKE ${format('%L', `%${args[0]}%`)}`;
+        case 'regex':
+            return `elem ~ ${format('%L', args[0])}`;
+        case 'iregex':
+            return `elem ~* ${format('%L', args[0])}`;
+        case 'before':
+            return `elem < ${format('%L', args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'after':
+            return `elem > ${format('%L', args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'containedBy':
+            return `elem <@ ${format('%L', JSON.stringify(args[0]))}::jsonb`;
+        case 'hasKey':
+            return `elem ? ${format('%L', args[0])}`;
+        case 'hasAnyKeys':
+            return `elem ?| ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'hasAllKeys':
+            return `elem ?& ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'typeOf':
+            return `jsonb_typeof(elem) = ${format('%L', args[0])}`;
+        case 'isNull':
+            return `elem IS NULL`;
+        case 'isNotNull':
+            return `elem IS NOT NULL`;
+        default:
+            return '';
+    }
+}
+function buildJsonbElementSQL(condition) {
+    const { path, op, args } = condition;
+    if (path.length === 0) {
+        return buildJsonbRootElementSQL(condition);
+    }
+    const extractText = path.length === 1
+        ? `elem->>${format('%L', path[0])}`
+        : `elem#>>'${`{${path.join(',')}}`}'`;
+    const extractJsonb = path.length === 1
+        ? `elem->${format('%L', path[0])}`
+        : `elem#>'${`{${path.join(',')}}`}'`;
+    switch (op) {
+        case 'equal':
+            return `${extractText} = ${format('%L', args[0])}`;
+        case 'notEqual':
+            return `${extractText} != ${format('%L', args[0])}`;
+        case 'greaterThan':
+            return typeof args[0] === 'number'
+                ? `(${extractText})::numeric > ${args[0]}`
+                : `${extractText} > ${format('%L', args[0])}`;
+        case 'greaterThanOrEqual':
+            return typeof args[0] === 'number'
+                ? `(${extractText})::numeric >= ${args[0]}`
+                : `${extractText} >= ${format('%L', args[0])}`;
+        case 'lessThan':
+            return typeof args[0] === 'number'
+                ? `(${extractText})::numeric < ${args[0]}`
+                : `${extractText} < ${format('%L', args[0])}`;
+        case 'lessThanOrEqual':
+            return typeof args[0] === 'number'
+                ? `(${extractText})::numeric <= ${args[0]}`
+                : `${extractText} <= ${format('%L', args[0])}`;
+        case 'between':
+            return typeof args[0] === 'number'
+                ? `(${extractText})::numeric BETWEEN ${args[0]} AND ${args[1]}`
+                : `${extractText} BETWEEN ${format('%L', args[0])} AND ${format('%L', args[1])}`;
+        case 'in': {
+            const inList = args[0].map(v => format('%L', v)).join(', ');
+            return `${extractText} IN (${inList})`;
+        }
+        case 'notIn': {
+            const notInList = args[0].map(v => format('%L', v)).join(', ');
+            return `${extractText} NOT IN (${notInList})`;
+        }
+        case 'like':
+            return `${extractText} LIKE ${format('%L', args[0])}`;
+        case 'ilike':
+            return `${extractText} ILIKE ${format('%L', args[0])}`;
+        case 'startsWith':
+            return `${extractText} LIKE ${format('%L', `${args[0]}%`)}`;
+        case 'endsWith':
+            return `${extractText} LIKE ${format('%L', `%${args[0]}`)}`;
+        case 'contains':
+            if (typeof args[0] === 'string') {
+                return `${extractText} LIKE ${format('%L', `%${args[0]}%`)}`;
+            }
+            return `${extractJsonb} @> ${format('%L', JSON.stringify(args[0]))}`;
+        case 'regex':
+            return `${extractText} ~ ${format('%L', args[0])}`;
+        case 'iregex':
+            return `${extractText} ~* ${format('%L', args[0])}`;
+        case 'before':
+            return `${extractText} < ${format('%L', args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'after':
+            return `${extractText} > ${format('%L', args[0] instanceof Date ? args[0].toISOString() : args[0])}`;
+        case 'isNull':
+            return `(${extractJsonb} IS NULL OR ${extractJsonb} = 'null'::jsonb)`;
+        case 'isNotNull':
+            return `(${extractJsonb} IS NOT NULL AND ${extractJsonb} != 'null'::jsonb)`;
+        case 'contains':
+            return `${extractJsonb} @> ${format('%L', JSON.stringify(args[0]))}`;
+        case 'containedBy':
+            return `${extractJsonb} <@ ${format('%L', JSON.stringify(args[0]))}`;
+        case 'hasKey':
+            return `${extractJsonb} ? ${format('%L', args[0])}`;
+        case 'hasAnyKeys':
+            return `${extractJsonb} ?| ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'hasAllKeys':
+            return `${extractJsonb} ?& ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'typeOf':
+            return `jsonb_typeof(${extractJsonb}) = ${format('%L', args[0])}`;
+        default:
+            return '';
+    }
+}
+function buildJsonbRootElementSQL(condition) {
+    const { op, args } = condition;
+    switch (op) {
+        case 'equal':
+            return `elem = ${format('%L', JSON.stringify(args[0]))}::jsonb`;
+        case 'notEqual':
+            return `elem != ${format('%L', JSON.stringify(args[0]))}::jsonb`;
+        case 'contains':
+            return `elem @> ${format('%L', JSON.stringify(args[0]))}::jsonb`;
+        case 'containedBy':
+            return `elem <@ ${format('%L', JSON.stringify(args[0]))}::jsonb`;
+        case 'hasKey':
+            return `elem ? ${format('%L', args[0])}`;
+        case 'hasAnyKeys':
+            return `elem ?| ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'hasAllKeys':
+            return `elem ?& ARRAY[${args[0].map(k => format('%L', k)).join(',')}]`;
+        case 'typeOf':
+            return `jsonb_typeof(elem) = ${format('%L', args[0])}`;
+        case 'isNull':
+            return `elem IS NULL`;
+        case 'isNotNull':
+            return `elem IS NOT NULL`;
+        default:
+            return '';
+    }
+}

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

@@ -1,6 +1,8 @@
-import format from "../shared/pg-format.js";
-import { JsonbConditionCollector, buildJsonbConditionSQL } from "./jsonb-condition-builder.js";
-import { ArrayConditionCollector, buildArrayConditionSQL } from "./array-condition-builder.js";
+import format from "../../shared/pg-format.js";
+import { buildJsonbConditionSQL } from "./jsonb-condition-builder.js";
+import { createJsonColumnProxy, buildPgJsonProxySQL } from "./json-path-proxy.js";
+import { createArrayColumnProxy, buildPgArrayProxySQL } from "./array-path-proxy.js";
+import { buildArrayConditionSQL } from "./array-condition-builder.js";
 import { FulltextConditionCollector, buildFulltextConditionSQL } from "./fulltext-condition-builder.js";
 import { RangeConditionCollector, buildRangeConditionSQL } from "./range-condition-builder.js";
 import { GeometricConditionCollector, buildGeometricConditionSQL } from "./geometric-condition-builder.js";
@@ -9,27 +11,28 @@ import { PostgisConditionCollector, buildPostgisConditionSQL } from "./postgis-c
 export class ConditionCollector {
     conditions = [];
     _tables;
-    _jsonb;
-    _array;
+    _tableName;
+    _jsonProxy;
+    _arrayProxy;
     _fulltext;
     _range;
     _geometric;
     _network;
     _postgis;
     get jsonb() {
-        if (!this._jsonb) {
-            this._jsonb = new JsonbConditionCollector(this);
+        if (!this._jsonProxy) {
+            this._jsonProxy = createJsonColumnProxy(this);
         }
-        return this._jsonb;
+        return this._jsonProxy;
     }
     get json() {
         return this.jsonb;
     }
     get array() {
-        if (!this._array) {
-            this._array = new ArrayConditionCollector(this);
+        if (!this._arrayProxy) {
+            this._arrayProxy = createArrayColumnProxy(this);
         }
-        return this._array;
+        return this._arrayProxy;
     }
     get fulltext() {
         if (!this._fulltext) {
@@ -294,6 +297,12 @@ function formatColumn(column) {
 }
 export function buildConditionSQL(condition) {
     const { method, column, values } = condition;
+    if (method === 'json_proxy') {
+        return buildPgJsonProxySQL(condition);
+    }
+    if (method.startsWith('array_proxy_')) {
+        return buildPgArrayProxySQL(condition);
+    }
     if (method.startsWith('jsonb_')) {
         return buildJsonbConditionSQL(condition);
     }

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

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

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

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