relq 1.0.0

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

@@ -0,0 +1,200 @@
+import format from "../../addons/pg-format.js";
+export class GeometricConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    contains(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_contains',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    containedBy(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_contained_by',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    overlaps(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_overlaps',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    strictlyLeft(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_strictly_left',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    strictlyRight(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_strictly_right',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    below(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_below',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    above(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_above',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    intersects(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_intersects',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    isHorizontal(column) {
+        this.parent.conditions.push({
+            method: 'geometric_is_horizontal',
+            column
+        });
+        return this.parent;
+    }
+    isVertical(column) {
+        this.parent.conditions.push({
+            method: 'geometric_is_vertical',
+            column
+        });
+        return this.parent;
+    }
+    isParallel(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_is_parallel',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    isPerpendicular(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_is_perpendicular',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    sameAs(column, value) {
+        this.parent.conditions.push({
+            method: 'geometric_same_as',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    distanceLessThan(column, value, maxDistance) {
+        this.parent.conditions.push({
+            method: 'geometric_distance_lt',
+            column,
+            values: { value, threshold: maxDistance }
+        });
+        return this.parent;
+    }
+    distanceLessThanOrEqual(column, value, maxDistance) {
+        this.parent.conditions.push({
+            method: 'geometric_distance_lte',
+            column,
+            values: { value, threshold: maxDistance }
+        });
+        return this.parent;
+    }
+    distanceGreaterThan(column, value, minDistance) {
+        this.parent.conditions.push({
+            method: 'geometric_distance_gt',
+            column,
+            values: { value, threshold: minDistance }
+        });
+        return this.parent;
+    }
+    distanceBetween(column, value, minDistance, maxDistance) {
+        this.parent.conditions.push({
+            method: 'geometric_distance_between',
+            column,
+            values: { value, min: minDistance, max: maxDistance }
+        });
+        return this.parent;
+    }
+    isClosed(column) {
+        this.parent.conditions.push({
+            method: 'geometric_is_closed',
+            column
+        });
+        return this.parent;
+    }
+    isOpen(column) {
+        this.parent.conditions.push({
+            method: 'geometric_is_open',
+            column
+        });
+        return this.parent;
+    }
+}
+export function buildGeometricConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'geometric_contains':
+            return format('%I @> %L', column, values);
+        case 'geometric_contained_by':
+            return format('%I <@ %L', column, values);
+        case 'geometric_overlaps':
+            return format('%I && %L', column, values);
+        case 'geometric_strictly_left':
+            return format('%I << %L', column, values);
+        case 'geometric_strictly_right':
+            return format('%I >> %L', column, values);
+        case 'geometric_below':
+            return format('%I <^ %L', column, values);
+        case 'geometric_above':
+            return format('%I >^ %L', column, values);
+        case 'geometric_intersects':
+            return format('%I ?# %L', column, values);
+        case 'geometric_is_horizontal':
+            return format('?- %I', column);
+        case 'geometric_is_vertical':
+            return format('?| %I', column);
+        case 'geometric_is_parallel':
+            return format('%I ?|| %L', column, values);
+        case 'geometric_is_perpendicular':
+            return format('%I ?-| %L', column, values);
+        case 'geometric_same_as':
+            return format('%I ~= %L', column, values);
+        case 'geometric_distance_lt':
+            return format('(%I <-> %L) < %s', column, values.value, values.threshold);
+        case 'geometric_distance_lte':
+            return format('(%I <-> %L) <= %s', column, values.value, values.threshold);
+        case 'geometric_distance_gt':
+            return format('(%I <-> %L) > %s', column, values.value, values.threshold);
+        case 'geometric_distance_between':
+            return format('(%I <-> %L) BETWEEN %s AND %s', column, values.value, values.min, values.max);
+        case 'geometric_is_closed':
+            return format('isclosed(%I)', column);
+        case 'geometric_is_open':
+            return format('isopen(%I)', column);
+        default:
+            return '';
+    }
+}

package/dist/esm/condition/index.js

@@ -0,0 +1,7 @@
+export { ConditionCollector, buildConditionSQL, buildConditionsSQL } from "./condition-collector.js";
+export { JsonbConditionCollector, buildJsonbConditionSQL } from "./jsonb-condition-builder.js";
+export { ArrayConditionCollector, buildArrayConditionSQL } from "./array-condition-builder.js";
+export { FulltextConditionCollector, buildFulltextConditionSQL } from "./fulltext-condition-builder.js";
+export { RangeConditionCollector, buildRangeConditionSQL } from "./range-condition-builder.js";
+export { GeometricConditionCollector, buildGeometricConditionSQL } from "./geometric-condition-builder.js";
+export { NetworkConditionCollector, buildNetworkConditionSQL } from "./network-condition-builder.js";

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

@@ -0,0 +1,152 @@
+import format from "../../addons/pg-format.js";
+export class JsonbConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    contains(column, value) {
+        this.parent.conditions.push({
+            method: 'jsonb_contains',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    containedBy(column, value) {
+        this.parent.conditions.push({
+            method: 'jsonb_contained_by',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    hasKey(column, key) {
+        this.parent.conditions.push({
+            method: 'jsonb_has_key',
+            column,
+            values: key
+        });
+        return this.parent;
+    }
+    hasAnyKeys(column, keys) {
+        this.parent.conditions.push({
+            method: 'jsonb_has_any_keys',
+            column,
+            values: keys
+        });
+        return this.parent;
+    }
+    hasAllKeys(column, keys) {
+        this.parent.conditions.push({
+            method: 'jsonb_has_all_keys',
+            column,
+            values: keys
+        });
+        return this.parent;
+    }
+    extract(column, path) {
+        this.parent.conditions.push({
+            method: 'jsonb_extract',
+            column,
+            values: path
+        });
+        return this.parent;
+    }
+    extractText(column, path) {
+        this.parent.conditions.push({
+            method: 'jsonb_extract_text',
+            column,
+            values: path
+        });
+        return this.parent;
+    }
+    get(column, key) {
+        this.parent.conditions.push({
+            method: 'jsonb_get',
+            column,
+            values: key
+        });
+        return this.parent;
+    }
+    getText(column, key) {
+        this.parent.conditions.push({
+            method: 'jsonb_get_text',
+            column,
+            values: key
+        });
+        return this.parent;
+    }
+    extractEqual(column, path, value) {
+        this.parent.conditions.push({
+            method: 'jsonb_extract_equal',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractGreaterThan(column, path, value) {
+        this.parent.conditions.push({
+            method: 'jsonb_extract_gt',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractLessThan(column, path, value) {
+        this.parent.conditions.push({
+            method: 'jsonb_extract_lt',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    extractIn(column, path, values) {
+        this.parent.conditions.push({
+            method: 'jsonb_extract_in',
+            column,
+            values: { path, values }
+        });
+        return this.parent;
+    }
+}
+export function buildJsonbConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'jsonb_contains':
+            return format('%I @> %L', column, JSON.stringify(values));
+        case 'jsonb_contained_by':
+            return format('%I <@ %L', column, JSON.stringify(values));
+        case 'jsonb_has_key':
+            return format('%I ? %L', column, values);
+        case 'jsonb_has_any_keys':
+            return format('%I ?| ARRAY[%s]', column, values.map(k => format('%L', k)).join(','));
+        case 'jsonb_has_all_keys':
+            return format('%I ?& ARRAY[%s]', column, values.map(k => format('%L', k)).join(','));
+        case 'jsonb_extract':
+            return format('%I#>%L', column, `{${values.join(',')}}`);
+        case 'jsonb_extract_text':
+            return format('%I#>>%L', column, `{${values.join(',')}}`);
+        case 'jsonb_get':
+            return format('%I->%L', column, values);
+        case 'jsonb_get_text':
+            return format('%I->>%L', column, values);
+        case 'jsonb_extract_equal': {
+            const { path, value } = values;
+            return format('%I#>>%L = %L', column, `{${path.join(',')}}`, value);
+        }
+        case 'jsonb_extract_gt': {
+            const { path, value } = values;
+            return format('(%I#>>%L)::numeric > %L', column, `{${path.join(',')}}`, value);
+        }
+        case 'jsonb_extract_lt': {
+            const { path, value } = values;
+            return format('(%I#>>%L)::numeric < %L', column, `{${path.join(',')}}`, value);
+        }
+        case 'jsonb_extract_in': {
+            const { path, values: inValues } = values;
+            return format('%I#>>%L IN %L', column, `{${path.join(',')}}`, inValues);
+        }
+        default:
+            return '';
+    }
+}

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

@@ -0,0 +1,222 @@
+import format from "../../addons/pg-format.js";
+export class NetworkConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    containedByStrict(column, value) {
+        this.parent.conditions.push({
+            method: 'network_contained_by_strict',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    containedByOrEqual(column, value) {
+        this.parent.conditions.push({
+            method: 'network_contained_by_or_equal',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    containsStrict(column, value) {
+        this.parent.conditions.push({
+            method: 'network_contains_strict',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    containsOrEqual(column, value) {
+        this.parent.conditions.push({
+            method: 'network_contains_or_equal',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    overlaps(column, value) {
+        this.parent.conditions.push({
+            method: 'network_overlaps',
+            column,
+            values: value
+        });
+        return this.parent;
+    }
+    sameFamily(column, value) {
+        this.parent.conditions.push({
+            method: 'network_same_family',
+            column,
+            values: 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/range-condition-builder.js

@@ -0,0 +1,74 @@
+import format from "../../addons/pg-format.js";
+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: range
+        });
+        return this.parent;
+    }
+    overlaps(column, range) {
+        this.parent.conditions.push({
+            method: 'range_overlaps',
+            column,
+            values: range
+        });
+        return this.parent;
+    }
+    strictlyLeft(column, range) {
+        this.parent.conditions.push({
+            method: 'range_strictly_left',
+            column,
+            values: range
+        });
+        return this.parent;
+    }
+    strictlyRight(column, range) {
+        this.parent.conditions.push({
+            method: 'range_strictly_right',
+            column,
+            values: range
+        });
+        return this.parent;
+    }
+    adjacent(column, range) {
+        this.parent.conditions.push({
+            method: 'range_adjacent',
+            column,
+            values: 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 '';
+    }
+}