relq 1.0.0

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

@@ -0,0 +1,208 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometricConditionCollector = void 0;
+exports.buildGeometricConditionSQL = buildGeometricConditionSQL;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+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;
+    }
+}
+exports.GeometricConditionCollector = GeometricConditionCollector;
+function buildGeometricConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'geometric_contains':
+            return (0, pg_format_1.default)('%I @> %L', column, values);
+        case 'geometric_contained_by':
+            return (0, pg_format_1.default)('%I <@ %L', column, values);
+        case 'geometric_overlaps':
+            return (0, pg_format_1.default)('%I && %L', column, values);
+        case 'geometric_strictly_left':
+            return (0, pg_format_1.default)('%I << %L', column, values);
+        case 'geometric_strictly_right':
+            return (0, pg_format_1.default)('%I >> %L', column, values);
+        case 'geometric_below':
+            return (0, pg_format_1.default)('%I <^ %L', column, values);
+        case 'geometric_above':
+            return (0, pg_format_1.default)('%I >^ %L', column, values);
+        case 'geometric_intersects':
+            return (0, pg_format_1.default)('%I ?# %L', column, values);
+        case 'geometric_is_horizontal':
+            return (0, pg_format_1.default)('?- %I', column);
+        case 'geometric_is_vertical':
+            return (0, pg_format_1.default)('?| %I', column);
+        case 'geometric_is_parallel':
+            return (0, pg_format_1.default)('%I ?|| %L', column, values);
+        case 'geometric_is_perpendicular':
+            return (0, pg_format_1.default)('%I ?-| %L', column, values);
+        case 'geometric_same_as':
+            return (0, pg_format_1.default)('%I ~= %L', column, values);
+        case 'geometric_distance_lt':
+            return (0, pg_format_1.default)('(%I <-> %L) < %s', column, values.value, values.threshold);
+        case 'geometric_distance_lte':
+            return (0, pg_format_1.default)('(%I <-> %L) <= %s', column, values.value, values.threshold);
+        case 'geometric_distance_gt':
+            return (0, pg_format_1.default)('(%I <-> %L) > %s', column, values.value, values.threshold);
+        case 'geometric_distance_between':
+            return (0, pg_format_1.default)('(%I <-> %L) BETWEEN %s AND %s', column, values.value, values.min, values.max);
+        case 'geometric_is_closed':
+            return (0, pg_format_1.default)('isclosed(%I)', column);
+        case 'geometric_is_open':
+            return (0, pg_format_1.default)('isopen(%I)', column);
+        default:
+            return '';
+    }
+}

package/dist/cjs/condition/index.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNetworkConditionSQL = exports.NetworkConditionCollector = exports.buildGeometricConditionSQL = exports.GeometricConditionCollector = exports.buildRangeConditionSQL = exports.RangeConditionCollector = exports.buildFulltextConditionSQL = exports.FulltextConditionCollector = exports.buildArrayConditionSQL = exports.ArrayConditionCollector = exports.buildJsonbConditionSQL = exports.JsonbConditionCollector = exports.buildConditionsSQL = exports.buildConditionSQL = exports.ConditionCollector = void 0;
+var condition_collector_1 = require("./condition-collector.cjs");
+Object.defineProperty(exports, "ConditionCollector", { enumerable: true, get: function () { return condition_collector_1.ConditionCollector; } });
+Object.defineProperty(exports, "buildConditionSQL", { enumerable: true, get: function () { return condition_collector_1.buildConditionSQL; } });
+Object.defineProperty(exports, "buildConditionsSQL", { enumerable: true, get: function () { return condition_collector_1.buildConditionsSQL; } });
+var jsonb_condition_builder_1 = require("./jsonb-condition-builder.cjs");
+Object.defineProperty(exports, "JsonbConditionCollector", { enumerable: true, get: function () { return jsonb_condition_builder_1.JsonbConditionCollector; } });
+Object.defineProperty(exports, "buildJsonbConditionSQL", { enumerable: true, get: function () { return jsonb_condition_builder_1.buildJsonbConditionSQL; } });
+var array_condition_builder_1 = require("./array-condition-builder.cjs");
+Object.defineProperty(exports, "ArrayConditionCollector", { enumerable: true, get: function () { return array_condition_builder_1.ArrayConditionCollector; } });
+Object.defineProperty(exports, "buildArrayConditionSQL", { enumerable: true, get: function () { return array_condition_builder_1.buildArrayConditionSQL; } });
+var fulltext_condition_builder_1 = require("./fulltext-condition-builder.cjs");
+Object.defineProperty(exports, "FulltextConditionCollector", { enumerable: true, get: function () { return fulltext_condition_builder_1.FulltextConditionCollector; } });
+Object.defineProperty(exports, "buildFulltextConditionSQL", { enumerable: true, get: function () { return fulltext_condition_builder_1.buildFulltextConditionSQL; } });
+var range_condition_builder_1 = require("./range-condition-builder.cjs");
+Object.defineProperty(exports, "RangeConditionCollector", { enumerable: true, get: function () { return range_condition_builder_1.RangeConditionCollector; } });
+Object.defineProperty(exports, "buildRangeConditionSQL", { enumerable: true, get: function () { return range_condition_builder_1.buildRangeConditionSQL; } });
+var geometric_condition_builder_1 = require("./geometric-condition-builder.cjs");
+Object.defineProperty(exports, "GeometricConditionCollector", { enumerable: true, get: function () { return geometric_condition_builder_1.GeometricConditionCollector; } });
+Object.defineProperty(exports, "buildGeometricConditionSQL", { enumerable: true, get: function () { return geometric_condition_builder_1.buildGeometricConditionSQL; } });
+var network_condition_builder_1 = require("./network-condition-builder.cjs");
+Object.defineProperty(exports, "NetworkConditionCollector", { enumerable: true, get: function () { return network_condition_builder_1.NetworkConditionCollector; } });
+Object.defineProperty(exports, "buildNetworkConditionSQL", { enumerable: true, get: function () { return network_condition_builder_1.buildNetworkConditionSQL; } });

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

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonbConditionCollector = void 0;
+exports.buildJsonbConditionSQL = buildJsonbConditionSQL;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+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;
+    }
+}
+exports.JsonbConditionCollector = JsonbConditionCollector;
+function buildJsonbConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'jsonb_contains':
+            return (0, pg_format_1.default)('%I @> %L', column, JSON.stringify(values));
+        case 'jsonb_contained_by':
+            return (0, pg_format_1.default)('%I <@ %L', column, JSON.stringify(values));
+        case 'jsonb_has_key':
+            return (0, pg_format_1.default)('%I ? %L', column, values);
+        case 'jsonb_has_any_keys':
+            return (0, pg_format_1.default)('%I ?| ARRAY[%s]', column, values.map(k => (0, pg_format_1.default)('%L', k)).join(','));
+        case 'jsonb_has_all_keys':
+            return (0, pg_format_1.default)('%I ?& ARRAY[%s]', column, values.map(k => (0, pg_format_1.default)('%L', k)).join(','));
+        case 'jsonb_extract':
+            return (0, pg_format_1.default)('%I#>%L', column, `{${values.join(',')}}`);
+        case 'jsonb_extract_text':
+            return (0, pg_format_1.default)('%I#>>%L', column, `{${values.join(',')}}`);
+        case 'jsonb_get':
+            return (0, pg_format_1.default)('%I->%L', column, values);
+        case 'jsonb_get_text':
+            return (0, pg_format_1.default)('%I->>%L', column, values);
+        case 'jsonb_extract_equal': {
+            const { path, value } = values;
+            return (0, pg_format_1.default)('%I#>>%L = %L', column, `{${path.join(',')}}`, value);
+        }
+        case 'jsonb_extract_gt': {
+            const { path, value } = values;
+            return (0, pg_format_1.default)('(%I#>>%L)::numeric > %L', column, `{${path.join(',')}}`, value);
+        }
+        case 'jsonb_extract_lt': {
+            const { path, value } = values;
+            return (0, pg_format_1.default)('(%I#>>%L)::numeric < %L', column, `{${path.join(',')}}`, value);
+        }
+        case 'jsonb_extract_in': {
+            const { path, values: inValues } = values;
+            return (0, pg_format_1.default)('%I#>>%L IN %L', column, `{${path.join(',')}}`, inValues);
+        }
+        default:
+            return '';
+    }
+}

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

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkConditionCollector = void 0;
+exports.buildNetworkConditionSQL = buildNetworkConditionSQL;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+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;
+    }
+}
+exports.NetworkConditionCollector = NetworkConditionCollector;
+function buildNetworkConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'network_contained_by_strict':
+            return (0, pg_format_1.default)('%I << inet %L', column, values);
+        case 'network_contained_by_or_equal':
+            return (0, pg_format_1.default)('%I <<= inet %L', column, values);
+        case 'network_contains_strict':
+            return (0, pg_format_1.default)('%I >> inet %L', column, values);
+        case 'network_contains_or_equal':
+            return (0, pg_format_1.default)('%I >>= inet %L', column, values);
+        case 'network_overlaps':
+            return (0, pg_format_1.default)('%I && inet %L', column, values);
+        case 'network_same_family':
+            return (0, pg_format_1.default)('inet_same_family(%I, inet %L)', column, values);
+        case 'network_is_ipv4':
+            return (0, pg_format_1.default)('family(%I) = 4', column);
+        case 'network_is_ipv6':
+            return (0, pg_format_1.default)('family(%I) = 6', column);
+        case 'network_masklen_eq':
+            return (0, pg_format_1.default)('masklen(%I) = %s', column, values);
+        case 'network_masklen_gt':
+            return (0, pg_format_1.default)('masklen(%I) > %s', column, values);
+        case 'network_masklen_lt':
+            return (0, pg_format_1.default)('masklen(%I) < %s', column, values);
+        case 'network_bitwise_and':
+            return (0, pg_format_1.default)('(%I & inet %L) = inet %L', column, values.mask, values.expected);
+        case 'network_bitwise_or':
+            return (0, pg_format_1.default)('(%I | inet %L) = inet %L', column, values.value, values.expected);
+        case 'network_mac_equals':
+            return (0, pg_format_1.default)('%I = macaddr %L', column, values);
+        case 'network_mac_not_equals':
+            return (0, pg_format_1.default)('%I <> macaddr %L', column, values);
+        case 'network_mac_gt':
+            return (0, pg_format_1.default)('%I > macaddr %L', column, values);
+        case 'network_mac_lt':
+            return (0, pg_format_1.default)('%I < macaddr %L', column, values);
+        case 'network_mac_trunc_equals':
+            return (0, pg_format_1.default)('trunc(%I) = macaddr %L', column, values);
+        case 'network_host_equals':
+            return (0, pg_format_1.default)('host(%I) = %L', column, values);
+        case 'network_network_equals':
+            return (0, pg_format_1.default)('network(%I) = cidr %L', column, values);
+        case 'network_broadcast_equals':
+            return (0, pg_format_1.default)('broadcast(%I) = inet %L', column, values);
+        default:
+            return '';
+    }
+}