relq 1.0.0

package/dist/cjs/condition/array-specialized-condition-builder.cjs

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jsonb = exports.Date = exports.Uuid = exports.ArrayJsonbConditionBuilder = exports.ArrayDateConditionBuilder = exports.ArrayUuidConditionBuilder = void 0;
+class ArrayUuidConditionBuilder {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    allValid(column) {
+        this.parent.conditions.push({
+            method: 'array_uuid_all_valid',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasVersion(column, version) {
+        this.parent.conditions.push({
+            method: 'array_uuid_has_version',
+            column,
+            values: { version }
+        });
+        return this.parent;
+    }
+    equals(column, uuid) {
+        this.parent.conditions.push({
+            method: 'array_uuid_equals',
+            column,
+            values: { uuid }
+        });
+        return this.parent;
+    }
+}
+exports.ArrayUuidConditionBuilder = ArrayUuidConditionBuilder;
+exports.Uuid = ArrayUuidConditionBuilder;
+class ArrayDateConditionBuilder {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    before(column, date) {
+        this.parent.conditions.push({
+            method: 'array_date_before',
+            column,
+            values: { date: date instanceof Date ? date.toISOString() : date }
+        });
+        return this.parent;
+    }
+    after(column, date) {
+        this.parent.conditions.push({
+            method: 'array_date_after',
+            column,
+            values: { date: date instanceof Date ? date.toISOString() : date }
+        });
+        return this.parent;
+    }
+    between(column, start, end) {
+        this.parent.conditions.push({
+            method: 'array_date_between',
+            column,
+            values: {
+                start: start instanceof Date ? start.toISOString() : start,
+                end: end instanceof Date ? end.toISOString() : end
+            }
+        });
+        return this.parent;
+    }
+    withinDays(column, days) {
+        this.parent.conditions.push({
+            method: 'array_date_within_days',
+            column,
+            values: { days }
+        });
+        return this.parent;
+    }
+    equals(column, date) {
+        this.parent.conditions.push({
+            method: 'array_date_equals',
+            column,
+            values: { date: date instanceof Date ? date.toISOString() : date }
+        });
+        return this.parent;
+    }
+    hasToday(column) {
+        this.parent.conditions.push({
+            method: 'array_date_has_today',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasPast(column) {
+        this.parent.conditions.push({
+            method: 'array_date_has_past',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasFuture(column) {
+        this.parent.conditions.push({
+            method: 'array_date_has_future',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasThisWeek(column) {
+        this.parent.conditions.push({
+            method: 'array_date_has_this_week',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasThisMonth(column) {
+        this.parent.conditions.push({
+            method: 'array_date_has_this_month',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasThisYear(column) {
+        this.parent.conditions.push({
+            method: 'array_date_has_this_year',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+}
+exports.ArrayDateConditionBuilder = ArrayDateConditionBuilder;
+exports.Date = ArrayDateConditionBuilder;
+class ArrayJsonbConditionBuilder {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    hasKey(column, key) {
+        this.parent.conditions.push({
+            method: 'array_jsonb_has_key',
+            column,
+            values: { key }
+        });
+        return this.parent;
+    }
+    hasPath(column, path) {
+        this.parent.conditions.push({
+            method: 'array_jsonb_has_path',
+            column,
+            values: { path }
+        });
+        return this.parent;
+    }
+    contains(column, value) {
+        this.parent.conditions.push({
+            method: 'array_jsonb_contains',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    containedBy(column, value) {
+        this.parent.conditions.push({
+            method: 'array_jsonb_contained_by',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    equals(column, value) {
+        this.parent.conditions.push({
+            method: 'array_jsonb_equals',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    pathEquals(column, path, value) {
+        this.parent.conditions.push({
+            method: 'array_jsonb_path_equals',
+            column,
+            values: { path, value }
+        });
+        return this.parent;
+    }
+    hasObject(column) {
+        this.parent.conditions.push({
+            method: 'array_jsonb_has_object',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasArray(column) {
+        this.parent.conditions.push({
+            method: 'array_jsonb_has_array',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+}
+exports.ArrayJsonbConditionBuilder = ArrayJsonbConditionBuilder;
+exports.Jsonb = ArrayJsonbConditionBuilder;

package/dist/cjs/condition/array-string-condition-builder.cjs

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayStringConditionBuilder = void 0;
+class ArrayStringConditionBuilder {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    startsWith(column, prefix) {
+        this.parent.conditions.push({
+            method: 'array_string_starts_with',
+            column,
+            values: { prefix }
+        });
+        return this.parent;
+    }
+    endsWith(column, suffix) {
+        this.parent.conditions.push({
+            method: 'array_string_ends_with',
+            column,
+            values: { suffix }
+        });
+        return this.parent;
+    }
+    contains(column, substring) {
+        this.parent.conditions.push({
+            method: 'array_string_contains',
+            column,
+            values: { substring }
+        });
+        return this.parent;
+    }
+    matches(column, pattern) {
+        this.parent.conditions.push({
+            method: 'array_string_matches',
+            column,
+            values: { pattern }
+        });
+        return this.parent;
+    }
+    imatches(column, pattern) {
+        this.parent.conditions.push({
+            method: 'array_string_imatches',
+            column,
+            values: { pattern }
+        });
+        return this.parent;
+    }
+    ilike(column, pattern) {
+        this.parent.conditions.push({
+            method: 'array_string_ilike',
+            column,
+            values: { pattern }
+        });
+        return this.parent;
+    }
+    allStartWith(column, prefix) {
+        this.parent.conditions.push({
+            method: 'array_string_all_start_with',
+            column,
+            values: { prefix }
+        });
+        return this.parent;
+    }
+    allEndWith(column, suffix) {
+        this.parent.conditions.push({
+            method: 'array_string_all_end_with',
+            column,
+            values: { suffix }
+        });
+        return this.parent;
+    }
+    allContain(column, substring) {
+        this.parent.conditions.push({
+            method: 'array_string_all_contain',
+            column,
+            values: { substring }
+        });
+        return this.parent;
+    }
+    lengthBetween(column, min, max) {
+        this.parent.conditions.push({
+            method: 'array_string_length_between',
+            column,
+            values: { min, max }
+        });
+        return this.parent;
+    }
+    hasEmpty(column) {
+        this.parent.conditions.push({
+            method: 'array_string_has_empty',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasNonEmpty(column) {
+        this.parent.conditions.push({
+            method: 'array_string_has_non_empty',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasUppercase(column) {
+        this.parent.conditions.push({
+            method: 'array_string_has_uppercase',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasLowercase(column) {
+        this.parent.conditions.push({
+            method: 'array_string_has_lowercase',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasNumeric(column) {
+        this.parent.conditions.push({
+            method: 'array_string_has_numeric',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    equals(column, value) {
+        this.parent.conditions.push({
+            method: 'array_string_equals',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    iequals(column, value) {
+        this.parent.conditions.push({
+            method: 'array_string_iequals',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+}
+exports.ArrayStringConditionBuilder = ArrayStringConditionBuilder;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/condition/condition-collector.cjs

@@ -0,0 +1,284 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionCollector = void 0;
+exports.buildConditionSQL = buildConditionSQL;
+exports.buildConditionsSQL = buildConditionsSQL;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+const jsonb_condition_builder_1 = require("./jsonb-condition-builder.cjs");
+const array_condition_builder_1 = require("./array-condition-builder.cjs");
+const fulltext_condition_builder_1 = require("./fulltext-condition-builder.cjs");
+const range_condition_builder_1 = require("./range-condition-builder.cjs");
+const geometric_condition_builder_1 = require("./geometric-condition-builder.cjs");
+const network_condition_builder_1 = require("./network-condition-builder.cjs");
+class ConditionCollector {
+    conditions = [];
+    _jsonb;
+    _array;
+    _fulltext;
+    _range;
+    _geometric;
+    _network;
+    get jsonb() {
+        if (!this._jsonb) {
+            this._jsonb = new jsonb_condition_builder_1.JsonbConditionCollector(this);
+        }
+        return this._jsonb;
+    }
+    get array() {
+        if (!this._array) {
+            this._array = new array_condition_builder_1.ArrayConditionCollector(this);
+        }
+        return this._array;
+    }
+    get fulltext() {
+        if (!this._fulltext) {
+            this._fulltext = new fulltext_condition_builder_1.FulltextConditionCollector(this);
+        }
+        return this._fulltext;
+    }
+    get range() {
+        if (!this._range) {
+            this._range = new range_condition_builder_1.RangeConditionCollector(this);
+        }
+        return this._range;
+    }
+    get geometric() {
+        if (!this._geometric) {
+            this._geometric = new geometric_condition_builder_1.GeometricConditionCollector(this);
+        }
+        return this._geometric;
+    }
+    get network() {
+        if (!this._network) {
+            this._network = new network_condition_builder_1.NetworkConditionCollector(this);
+        }
+        return this._network;
+    }
+    equal(column, value) {
+        this.conditions.push({ method: 'equal', column, values: value });
+        return this;
+    }
+    notEqual(column, value) {
+        this.conditions.push({ method: 'notEqual', column, values: value });
+        return this;
+    }
+    lessThan(column, value) {
+        this.conditions.push({ method: 'lessThan', column, values: value });
+        return this;
+    }
+    lessThanEqual(column, value) {
+        this.conditions.push({ method: 'lessThanEqual', column, values: value });
+        return this;
+    }
+    greaterThan(column, value) {
+        this.conditions.push({ method: 'greaterThan', column, values: value });
+        return this;
+    }
+    greaterThanEqual(column, value) {
+        this.conditions.push({ method: 'greaterThanEqual', column, values: value });
+        return this;
+    }
+    isNull(column) {
+        this.conditions.push({ method: 'isNull', column });
+        return this;
+    }
+    isNotNull(column) {
+        this.conditions.push({ method: 'isNotNull', column });
+        return this;
+    }
+    between(column, start, end) {
+        this.conditions.push({ method: 'between', column, values: [start, end] });
+        return this;
+    }
+    notBetween(column, start, end) {
+        this.conditions.push({ method: 'notBetween', column, values: [start, end] });
+        return this;
+    }
+    startsWith(column, value) {
+        this.conditions.push({ method: 'startsWith', column, values: value });
+        return this;
+    }
+    notStartsWith(column, value) {
+        this.conditions.push({ method: 'notStartsWith', column, values: value });
+        return this;
+    }
+    endsWith(column, value) {
+        this.conditions.push({ method: 'endsWith', column, values: value });
+        return this;
+    }
+    notEndsWith(column, value) {
+        this.conditions.push({ method: 'notEndsWith', column, values: value });
+        return this;
+    }
+    contains(column, value) {
+        this.conditions.push({ method: 'contains', column, values: value });
+        return this;
+    }
+    notContains(column, value) {
+        this.conditions.push({ method: 'notContains', column, values: value });
+        return this;
+    }
+    like(column, pattern) {
+        this.conditions.push({ method: 'like', column, values: pattern });
+        return this;
+    }
+    notLike(column, pattern) {
+        this.conditions.push({ method: 'notLike', column, values: pattern });
+        return this;
+    }
+    ilike(column, pattern) {
+        this.conditions.push({ method: 'ilike', column, values: pattern });
+        return this;
+    }
+    in(column, values) {
+        this.conditions.push({ method: 'in', column, values });
+        return this;
+    }
+    notIn(column, values) {
+        this.conditions.push({ method: 'notIn', column, values });
+        return this;
+    }
+    exists(subquery) {
+        this.conditions.push({ method: 'exists', values: subquery });
+        return this;
+    }
+    notExists(subquery) {
+        this.conditions.push({ method: 'notExists', values: subquery });
+        return this;
+    }
+    search(column, value) {
+        this.conditions.push({ method: 'search', column, values: value });
+        return this;
+    }
+    notSearch(column, value) {
+        this.conditions.push({ method: 'notSearch', column, values: value });
+        return this;
+    }
+    or(callback) {
+        const subBuilder = new ConditionCollector();
+        callback(subBuilder);
+        this.conditions.push({ method: 'or', values: subBuilder.getConditions() });
+        return this;
+    }
+    and(callback) {
+        const subBuilder = new ConditionCollector();
+        callback(subBuilder);
+        this.conditions.push({ method: 'and', values: subBuilder.getConditions() });
+        return this;
+    }
+    raw(condition) {
+        this.conditions.push({ method: 'raw', values: condition });
+        return this;
+    }
+    getConditions() {
+        return this.conditions;
+    }
+}
+exports.ConditionCollector = ConditionCollector;
+function buildConditionSQL(condition) {
+    const { method, column, values } = condition;
+    if (method.startsWith('jsonb_')) {
+        return (0, jsonb_condition_builder_1.buildJsonbConditionSQL)(condition);
+    }
+    if (method.startsWith('array_')) {
+        return (0, array_condition_builder_1.buildArrayConditionSQL)(condition);
+    }
+    if (method.startsWith('fulltext_')) {
+        return (0, fulltext_condition_builder_1.buildFulltextConditionSQL)(condition);
+    }
+    if (method.startsWith('range_')) {
+        return (0, range_condition_builder_1.buildRangeConditionSQL)(condition);
+    }
+    if (method.startsWith('geometric_')) {
+        return (0, geometric_condition_builder_1.buildGeometricConditionSQL)(condition);
+    }
+    if (method.startsWith('network_')) {
+        return (0, network_condition_builder_1.buildNetworkConditionSQL)(condition);
+    }
+    switch (method) {
+        case 'equal':
+            if (Array.isArray(values) && values.length > 1) {
+                return (0, pg_format_1.default)('%I IN %L', column, values);
+            }
+            return (0, pg_format_1.default)('%I = %L', column, Array.isArray(values) ? values[0] : values);
+        case 'notEqual':
+            if (Array.isArray(values) && values.length > 1) {
+                return (0, pg_format_1.default)('%I NOT IN %L', column, values);
+            }
+            return (0, pg_format_1.default)('%I != %L', column, Array.isArray(values) ? values[0] : values);
+        case 'lessThan':
+            return (0, pg_format_1.default)('%I < %L', column, Array.isArray(values) ? values[0] : values);
+        case 'lessThanEqual':
+            return (0, pg_format_1.default)('%I <= %L', column, Array.isArray(values) ? values[0] : values);
+        case 'greaterThan':
+            return (0, pg_format_1.default)('%I > %L', column, Array.isArray(values) ? values[0] : values);
+        case 'greaterThanEqual':
+            return (0, pg_format_1.default)('%I >= %L', column, Array.isArray(values) ? values[0] : values);
+        case 'isNull':
+            return (0, pg_format_1.default)('%I IS NULL', column);
+        case 'isNotNull':
+            return (0, pg_format_1.default)('%I IS NOT NULL', column);
+        case 'between': {
+            const [start, end] = values;
+            return (0, pg_format_1.default)('%I BETWEEN %L AND %L', column, start, end);
+        }
+        case 'notBetween': {
+            const [notStart, notEnd] = values;
+            return (0, pg_format_1.default)('%I NOT BETWEEN %L AND %L', column, notStart, notEnd);
+        }
+        case 'startsWith':
+            return (0, pg_format_1.default)('%I LIKE %L', column, `${values}%`);
+        case 'notStartsWith':
+            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `${values}%`);
+        case 'endsWith':
+            return (0, pg_format_1.default)('%I LIKE %L', column, `%${values}`);
+        case 'notEndsWith':
+            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `%${values}`);
+        case 'contains':
+            return (0, pg_format_1.default)('%I LIKE %L', column, `%${values}%`);
+        case 'notContains':
+            return (0, pg_format_1.default)('%I NOT LIKE %L', column, `%${values}%`);
+        case 'like':
+            return (0, pg_format_1.default)('%I LIKE %L', column, values);
+        case 'notLike':
+            return (0, pg_format_1.default)('%I NOT LIKE %L', column, values);
+        case 'ilike':
+            return (0, pg_format_1.default)('%I ILIKE %L', column, values);
+        case 'in': {
+            const valueList = Array.isArray(values) ? values : [values];
+            const formattedValues = valueList.map(v => (0, pg_format_1.default)('%L', v)).join(', ');
+            return (0, pg_format_1.default)('%I IN (%s)', column, formattedValues);
+        }
+        case 'notIn': {
+            const valueList = Array.isArray(values) ? values : [values];
+            const formattedValues = valueList.map(v => (0, pg_format_1.default)('%L', v)).join(', ');
+            return (0, pg_format_1.default)('%I NOT IN (%s)', column, formattedValues);
+        }
+        case 'exists':
+            return (0, pg_format_1.default)('EXISTS (%s)', values);
+        case 'notExists':
+            return (0, pg_format_1.default)('NOT EXISTS (%s)', values);
+        case 'search':
+            return (0, pg_format_1.default)('to_tsvector(%I) @@ plainto_tsquery(%L)', column, values);
+        case 'notSearch':
+            return (0, pg_format_1.default)('NOT (to_tsvector(%I) @@ plainto_tsquery(%L))', column, values);
+        case 'or': {
+            const orConditions = values;
+            return `(${orConditions.map(c => buildConditionSQL(c)).join(' OR ')})`;
+        }
+        case 'and': {
+            const andConditions = values;
+            return `(${andConditions.map(c => buildConditionSQL(c)).join(' AND ')})`;
+        }
+        case 'raw':
+            return values;
+        default:
+            return '';
+    }
+}
+function buildConditionsSQL(conditions) {
+    return conditions.map(condition => buildConditionSQL(condition)).join(' AND ');
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FulltextConditionCollector = void 0;
+exports.buildFulltextConditionSQL = buildFulltextConditionSQL;
+const pg_format_1 = __importDefault(require("../../addons/pg-format.js"));
+class FulltextConditionCollector {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    search(column, query, config = 'english') {
+        this.parent.conditions.push({
+            method: 'fulltext_search',
+            column,
+            values: { query, config }
+        });
+        return this.parent;
+    }
+    match(column, query, config = 'english') {
+        return this.search(column, query, config);
+    }
+    rank(column, query, minRank = 0, config = 'english') {
+        this.parent.conditions.push({
+            method: 'fulltext_rank',
+            column,
+            values: { query, minRank, config }
+        });
+        return this.parent;
+    }
+}
+exports.FulltextConditionCollector = FulltextConditionCollector;
+function buildFulltextConditionSQL(condition) {
+    const { method, column, values } = condition;
+    switch (method) {
+        case 'fulltext_search': {
+            const { query, config } = values;
+            const isTsVector = column?.endsWith('_vector') || column?.endsWith('_tsvector');
+            if (isTsVector) {
+                return (0, pg_format_1.default)('%I @@ plainto_tsquery(%L, %L)', column, config, query);
+            }
+            else {
+                return (0, pg_format_1.default)('to_tsvector(%L, %I) @@ plainto_tsquery(%L, %L)', config, column, config, query);
+            }
+        }
+        case 'fulltext_rank': {
+            const { query, minRank, config } = values;
+            const isTsVector = column?.endsWith('_vector') || column?.endsWith('_tsvector');
+            if (isTsVector) {
+                return (0, pg_format_1.default)('ts_rank(%I, plainto_tsquery(%L, %L)) > %L', column, config, query, minRank);
+            }
+            else {
+                return (0, pg_format_1.default)('ts_rank(to_tsvector(%L, %I), plainto_tsquery(%L, %L)) > %L', config, column, config, query, minRank);
+            }
+        }
+        default:
+            return '';
+    }
+}