@relq/orm 0.1.0

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayNumericConditionBuilder = void 0;
+class ArrayNumericConditionBuilder {
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    greaterThan(column, value) {
+        this.parent.conditions.push({
+            method: 'array_numeric_greater_than',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    greaterThanOrEqual(column, value) {
+        this.parent.conditions.push({
+            method: 'array_numeric_greater_than_or_equal',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    lessThan(column, value) {
+        this.parent.conditions.push({
+            method: 'array_numeric_less_than',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    lessThanOrEqual(column, value) {
+        this.parent.conditions.push({
+            method: 'array_numeric_less_than_or_equal',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    between(column, min, max) {
+        this.parent.conditions.push({
+            method: 'array_numeric_between',
+            column,
+            values: { min, max }
+        });
+        return this.parent;
+    }
+    allGreaterThan(column, value) {
+        this.parent.conditions.push({
+            method: 'array_numeric_all_greater_than',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    allLessThan(column, value) {
+        this.parent.conditions.push({
+            method: 'array_numeric_all_less_than',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    allBetween(column, min, max) {
+        this.parent.conditions.push({
+            method: 'array_numeric_all_between',
+            column,
+            values: { min, max }
+        });
+        return this.parent;
+    }
+    sumEquals(column, target) {
+        this.parent.conditions.push({
+            method: 'array_numeric_sum_equals',
+            column,
+            values: { target }
+        });
+        return this.parent;
+    }
+    sumGreaterThan(column, target) {
+        this.parent.conditions.push({
+            method: 'array_numeric_sum_greater_than',
+            column,
+            values: { target }
+        });
+        return this.parent;
+    }
+    sumLessThan(column, target) {
+        this.parent.conditions.push({
+            method: 'array_numeric_sum_less_than',
+            column,
+            values: { target }
+        });
+        return this.parent;
+    }
+    avgEquals(column, target) {
+        this.parent.conditions.push({
+            method: 'array_numeric_avg_equals',
+            column,
+            values: { target }
+        });
+        return this.parent;
+    }
+    avgGreaterThan(column, target) {
+        this.parent.conditions.push({
+            method: 'array_numeric_avg_greater_than',
+            column,
+            values: { target }
+        });
+        return this.parent;
+    }
+    avgLessThan(column, target) {
+        this.parent.conditions.push({
+            method: 'array_numeric_avg_less_than',
+            column,
+            values: { target }
+        });
+        return this.parent;
+    }
+    maxEquals(column, target) {
+        this.parent.conditions.push({
+            method: 'array_numeric_max_equals',
+            column,
+            values: { target }
+        });
+        return this.parent;
+    }
+    minEquals(column, target) {
+        this.parent.conditions.push({
+            method: 'array_numeric_min_equals',
+            column,
+            values: { target }
+        });
+        return this.parent;
+    }
+    equals(column, value) {
+        this.parent.conditions.push({
+            method: 'array_numeric_equals',
+            column,
+            values: { value }
+        });
+        return this.parent;
+    }
+    hasEven(column) {
+        this.parent.conditions.push({
+            method: 'array_numeric_has_even',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasOdd(column) {
+        this.parent.conditions.push({
+            method: 'array_numeric_has_odd',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasPositive(column) {
+        this.parent.conditions.push({
+            method: 'array_numeric_has_positive',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasNegative(column) {
+        this.parent.conditions.push({
+            method: 'array_numeric_has_negative',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+    hasZero(column) {
+        this.parent.conditions.push({
+            method: 'array_numeric_has_zero',
+            column,
+            values: {}
+        });
+        return this.parent;
+    }
+}
+exports.ArrayNumericConditionBuilder = ArrayNumericConditionBuilder;

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 });