directus 9.9.0 → 9.11.0

package/dist/utils/{apply-query.d.ts → apply-query/index.d.ts}

@@ -1,9 +1,10 @@
-import { Knex } from 'knex';
 import { Aggregate, Filter, Query, SchemaOverview } from '@directus/shared/types';
+import { Knex } from 'knex';
 /**
  * Apply the Query to a given Knex query builder instance
  */
 export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, subQuery?: boolean): Knex.QueryBuilder;
+export declare function applySort(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootSort: string[], collection: string, subQuery?: boolean): void;
 export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, subQuery?: boolean): Knex.QueryBuilder<any, any>;
 export declare function applySearch(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): Promise<void>;
 export declare function applyAggregate(dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string): void;

package/dist/utils/apply-query/index.js

@@ -0,0 +1,394 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAggregate = exports.applySearch = exports.applyFilter = exports.applySort = void 0;
+const lodash_1 = require("lodash");
+const nanoid_1 = require("nanoid");
+const uuid_validate_1 = __importDefault(require("uuid-validate"));
+const helpers_1 = require("../../database/helpers");
+const invalid_query_1 = require("../../exceptions/invalid-query");
+const get_column_1 = require("../get-column");
+const get_column_path_1 = require("../get-column-path");
+const get_relation_info_1 = require("../get-relation-info");
+const operators_1 = __importDefault(require("./operators"));
+const generateAlias = (0, nanoid_1.customAlphabet)('abcdefghijklmnopqrstuvwxyz', 5);
+/**
+ * Apply the Query to a given Knex query builder instance
+ */
+function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false) {
+    if (query.sort) {
+        applySort(knex, schema, dbQuery, query.sort, collection, subQuery);
+    }
+    if (typeof query.limit === 'number' && query.limit !== -1) {
+        dbQuery.limit(query.limit);
+    }
+    if (query.offset) {
+        dbQuery.offset(query.offset);
+    }
+    if (query.page && query.limit && query.limit !== -1) {
+        dbQuery.offset(query.limit * (query.page - 1));
+    }
+    if (query.search) {
+        applySearch(schema, dbQuery, query.search, collection);
+    }
+    if (query.group) {
+        dbQuery.groupBy(query.group.map((column) => (0, get_column_1.getColumn)(knex, collection, column, false, schema)));
+    }
+    if (query.aggregate) {
+        applyAggregate(dbQuery, query.aggregate, collection);
+    }
+    if (query.filter) {
+        applyFilter(knex, schema, dbQuery, query.filter, collection, subQuery);
+    }
+    return dbQuery;
+}
+exports.default = applyQuery;
+function addJoin({ path, collection, aliasMap, rootQuery, subQuery, schema, relations, knex }) {
+    path = (0, lodash_1.clone)(path);
+    followRelation(path);
+    function followRelation(pathParts, parentCollection = collection, parentAlias) {
+        /**
+         * For A2M fields, the path can contain an optional collection scope <field>:<scope>
+         */
+        const pathRoot = pathParts[0].split(':')[0];
+        const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, parentCollection, pathRoot);
+        if (!relation) {
+            return;
+        }
+        const alias = generateAlias();
+        (0, lodash_1.set)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts, alias);
+        if (relationType === 'm2o') {
+            rootQuery.leftJoin({ [alias]: relation.related_collection }, `${parentAlias || parentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
+        }
+        if (relationType === 'a2o') {
+            const pathScope = pathParts[0].split(':')[1];
+            if (!pathScope) {
+                throw new invalid_query_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+            }
+            rootQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
+                joinClause
+                    .onVal(relation.meta.one_collection_field, '=', pathScope)
+                    .andOn(`${parentAlias || parentCollection}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${alias}.${schema.collections[pathScope].primary}`));
+            });
+        }
+        if (relationType === 'o2a') {
+            rootQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
+                joinClause
+                    .onVal(relation.meta.one_collection_field, '=', parentCollection)
+                    .andOn(`${alias}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${parentAlias || parentCollection}.${schema.collections[parentCollection].primary}`));
+            });
+        }
+        // Still join o2m relations when in subquery OR when the o2m relation is not at the root level
+        if (relationType === 'o2m' && (subQuery === true || parentAlias !== undefined)) {
+            rootQuery.leftJoin({ [alias]: relation.collection }, `${parentAlias || parentCollection}.${schema.collections[relation.related_collection].primary}`, `${alias}.${relation.field}`);
+        }
+        if (relationType === 'm2o' || subQuery === true || (relationType === 'o2m' && parentAlias !== undefined)) {
+            let parent;
+            if (relationType === 'm2o') {
+                parent = relation.related_collection;
+            }
+            else if (relationType === 'a2o') {
+                const pathScope = pathParts[0].split(':')[1];
+                if (!pathScope) {
+                    throw new invalid_query_1.InvalidQueryException(`You have to provide a collection scope when sorting or filtering on a many-to-any item`);
+                }
+                parent = pathScope;
+            }
+            else {
+                parent = relation.collection;
+            }
+            pathParts.shift();
+            if (pathParts.length) {
+                followRelation(pathParts, parent, alias);
+            }
+        }
+    }
+}
+function applySort(knex, schema, rootQuery, rootSort, collection, subQuery = false) {
+    const relations = schema.relations;
+    const aliasMap = {};
+    rootQuery.orderBy(rootSort.map((sortField) => {
+        const column = sortField.split('.');
+        let order = 'asc';
+        if (column.length > 1) {
+            if (sortField.startsWith('-')) {
+                order = 'desc';
+            }
+            if (column[0].startsWith('-')) {
+                column[0] = column[0].substring(1);
+            }
+            addJoin({
+                path: column,
+                collection,
+                aliasMap,
+                rootQuery,
+                subQuery,
+                schema,
+                relations,
+                knex,
+            });
+            const colPath = (0, get_column_path_1.getColumnPath)({ path: column, collection, aliasMap, relations }) || '';
+            const [alias, field] = colPath.split('.');
+            return {
+                order,
+                column: (0, get_column_1.getColumn)(knex, alias, field, false, schema),
+            };
+        }
+        let col = column[0];
+        if (sortField.startsWith('-')) {
+            col = column[0].substring(1);
+            order = 'desc';
+        }
+        return {
+            order,
+            column: (0, get_column_1.getColumn)(knex, collection, col, false, schema),
+        };
+    }));
+}
+exports.applySort = applySort;
+function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery = false) {
+    const helpers = (0, helpers_1.getHelpers)(knex);
+    const relations = schema.relations;
+    const aliasMap = {};
+    addJoins(rootQuery, rootFilter, collection);
+    addWhereClauses(knex, rootQuery, rootFilter, collection);
+    return rootQuery;
+    function isNegativeOperator(operator) {
+        return operator.indexOf('_n') === 0;
+    }
+    function addJoins(dbQuery, filter, collection) {
+        for (const [key, value] of Object.entries(filter)) {
+            if (key === '_or' || key === '_and') {
+                // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
+                // permission checks, as {} already matches full permissions.
+                if (key === '_or' && value.some((subFilter) => Object.keys(subFilter).length === 0))
+                    continue;
+                value.forEach((subFilter) => {
+                    addJoins(dbQuery, subFilter, collection);
+                });
+                continue;
+            }
+            const filterPath = getFilterPath(key, value);
+            if (filterPath.length > 1) {
+                addJoin({
+                    path: filterPath,
+                    collection,
+                    knex,
+                    schema,
+                    relations,
+                    subQuery,
+                    rootQuery,
+                    aliasMap,
+                });
+            }
+        }
+    }
+    function callbackSubqueryRelation(relation, value) {
+        return function (subQueryKnex) {
+            const field = relation.field;
+            const collection = relation.collection;
+            const column = `${collection}.${field}`;
+            subQueryKnex.from(collection).whereRaw(`${field} = ${column}`);
+            applyQuery(knex, relation.collection, subQueryKnex, {
+                filter: value,
+            }, schema, true);
+        };
+    }
+    function inverseFilters(value) {
+        for (const field in value) {
+            for (const operator in value[field]) {
+                let inverseOperator = operator;
+                if (isNegativeOperator(operator)) {
+                    inverseOperator = '_' + operator.substring(2);
+                }
+                else {
+                    inverseOperator = '_n' + operator.substring(1);
+                }
+                value[field][inverseOperator] = value[field][operator];
+                delete value[field][operator];
+            }
+        }
+    }
+    function addWhereClauses(knex, dbQuery, filter, collection, logical = 'and') {
+        for (const [key, value] of Object.entries(filter)) {
+            if (key === '_or' || key === '_and') {
+                // If the _or array contains an empty object (full permissions), we should short-circuit and ignore all other
+                // permission checks, as {} already matches full permissions.
+                if (key === '_or' && value.some((subFilter) => Object.keys(subFilter).length === 0)) {
+                    continue;
+                }
+                /** @NOTE this callback function isn't called until Knex runs the query */
+                dbQuery[logical].where((subQuery) => {
+                    value.forEach((subFilter) => {
+                        addWhereClauses(knex, subQuery, subFilter, collection, key === '_and' ? 'and' : 'or');
+                    });
+                });
+                continue;
+            }
+            const filterPath = getFilterPath(key, value);
+            /**
+             * For A2M fields, the path can contain an optional collection scope <field>:<scope>
+             */
+            const pathRoot = filterPath[0].split(':')[0];
+            const { relation, relationType } = (0, get_relation_info_1.getRelationInfo)(relations, collection, pathRoot);
+            const { operator: filterOperator, value: filterValue } = getOperation(key, value);
+            if (relationType === 'm2o' || relationType === 'a2o' || relationType === null) {
+                if (filterPath.length > 1) {
+                    const columnName = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
+                    if (!columnName)
+                        continue;
+                    applyFilterToQuery(columnName, filterOperator, filterValue, logical);
+                }
+                else {
+                    applyFilterToQuery(`${collection}.${filterPath[0]}`, filterOperator, filterValue, logical);
+                }
+            }
+            else if (subQuery === false || filterPath.length > 1) {
+                if (!relation)
+                    continue;
+                let pkField = `${collection}.${schema.collections[relation.related_collection].primary}`;
+                if (relationType === 'o2a') {
+                    pkField = knex.raw(`CAST(?? AS CHAR(255))`, [pkField]);
+                }
+                if (isNegativeOperator(filterOperator)) {
+                    inverseFilters(value);
+                    dbQuery[logical].whereNotExists(callbackSubqueryRelation(relation, value));
+                }
+                else {
+                    dbQuery[logical].whereExists(callbackSubqueryRelation(relation, value));
+                }
+            }
+        }
+        function applyFilterToQuery(key, operator, compareValue, logical = 'and') {
+            const [table, column] = key.split('.');
+            // Is processed through Knex.Raw, so should be safe to string-inject into these where queries
+            const selectionRaw = (0, get_column_1.getColumn)(knex, table, column, false, schema);
+            // Knex supports "raw" in the columnName parameter, but isn't typed as such. Too bad..
+            // See https://github.com/knex/knex/issues/4518 @TODO remove as any once knex is updated
+            const [collection, field] = key.split('.');
+            if (collection in schema.collections && field in schema.collections[collection].fields) {
+                const type = schema.collections[collection].fields[field].type;
+                if (['date', 'dateTime', 'time', 'timestamp'].includes(type)) {
+                    if (Array.isArray(compareValue)) {
+                        compareValue = compareValue.map((val) => helpers.date.parse(val));
+                    }
+                    else {
+                        compareValue = helpers.date.parse(compareValue);
+                    }
+                }
+                if (['bigInteger', 'integer', 'float', 'decimal'].includes(type)) {
+                    if (Array.isArray(compareValue)) {
+                        compareValue = compareValue.map((val) => Number(val));
+                    }
+                    else {
+                        compareValue = Number(compareValue);
+                    }
+                }
+            }
+            // The following fields however, require a value to be run. If no value is passed, we
+            // ignore them. This allows easier use in GraphQL, where you wouldn't be able to
+            // conditionally build out your filter structure (#4471)
+            if (compareValue === undefined)
+                return;
+            if (Array.isArray(compareValue)) {
+                // Tip: when using a `[Type]` type in GraphQL, but don't provide the variable, it'll be
+                // reported as [undefined].
+                // We need to remove any undefined values, as they are useless
+                compareValue = compareValue.filter((val) => val !== undefined);
+            }
+            if (operator in operators_1.default) {
+                operators_1.default[operator].apply({
+                    query: dbQuery[logical],
+                    helpers,
+                    selectionRaw,
+                    compareValue,
+                });
+            }
+            else {
+                throw new Error(`Operator ${operator} not supported`);
+            }
+        }
+    }
+}
+exports.applyFilter = applyFilter;
+async function applySearch(schema, dbQuery, searchQuery, collection) {
+    const fields = Object.entries(schema.collections[collection].fields);
+    dbQuery.andWhere(function () {
+        fields.forEach(([name, field]) => {
+            if (['text', 'string'].includes(field.type)) {
+                this.orWhereRaw(`LOWER(??) LIKE ?`, [`${collection}.${name}`, `%${searchQuery.toLowerCase()}%`]);
+            }
+            else if (['bigInteger', 'integer', 'decimal', 'float'].includes(field.type)) {
+                const number = Number(searchQuery);
+                if (!isNaN(number))
+                    this.orWhere({ [`${collection}.${name}`]: number });
+            }
+            else if (field.type === 'uuid' && (0, uuid_validate_1.default)(searchQuery)) {
+                this.orWhere({ [`${collection}.${name}`]: searchQuery });
+            }
+        });
+    });
+}
+exports.applySearch = applySearch;
+function applyAggregate(dbQuery, aggregate, collection) {
+    for (const [operation, fields] of Object.entries(aggregate)) {
+        if (!fields)
+            continue;
+        for (const field of fields) {
+            if (operation === 'avg') {
+                dbQuery.avg(`${collection}.${field}`, { as: `avg->${field}` });
+            }
+            if (operation === 'avgDistinct') {
+                dbQuery.avgDistinct(`${collection}.${field}`, { as: `avgDistinct->${field}` });
+            }
+            if (operation === 'countAll') {
+                dbQuery.count('*', { as: 'countAll' });
+            }
+            if (operation === 'count') {
+                if (field === '*') {
+                    dbQuery.count('*', { as: 'count' });
+                }
+                else {
+                    dbQuery.count(`${collection}.${field}`, { as: `count->${field}` });
+                }
+            }
+            if (operation === 'countDistinct') {
+                dbQuery.countDistinct(`${collection}.${field}`, { as: `countDistinct->${field}` });
+            }
+            if (operation === 'sum') {
+                dbQuery.sum(`${collection}.${field}`, { as: `sum->${field}` });
+            }
+            if (operation === 'sumDistinct') {
+                dbQuery.sumDistinct(`${collection}.${field}`, { as: `sumDistinct->${field}` });
+            }
+            if (operation === 'min') {
+                dbQuery.min(`${collection}.${field}`, { as: `min->${field}` });
+            }
+            if (operation === 'max') {
+                dbQuery.max(`${collection}.${field}`, { as: `max->${field}` });
+            }
+        }
+    }
+}
+exports.applyAggregate = applyAggregate;
+function getFilterPath(key, value) {
+    const path = [key];
+    if (typeof Object.keys(value)[0] === 'string' && Object.keys(value)[0].startsWith('_') === true) {
+        return path;
+    }
+    if ((0, lodash_1.isPlainObject)(value)) {
+        path.push(...getFilterPath(Object.keys(value)[0], Object.values(value)[0]));
+    }
+    return path;
+}
+function getOperation(key, value) {
+    if (key.startsWith('_') && key !== '_and' && key !== '_or') {
+        return { operator: key, value };
+    }
+    else if ((0, lodash_1.isPlainObject)(value) === false) {
+        return { operator: '_eq', value };
+    }
+    return getOperation(Object.keys(value)[0], Object.values(value)[0]);
+}

package/dist/utils/apply-query/operators/between.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/between.operator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_between',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        let value = compareValue;
+        if (typeof value === 'string')
+            value = value.split(',');
+        if (!(value instanceof Array))
+            throw new Error('Invalid value for between operator');
+        if (value.length !== 2)
+            throw new Error('Expected two values for between operator');
+        query.whereBetween(selectionRaw, value);
+    },
+});

package/dist/utils/apply-query/operators/contains.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/contains.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_contains',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.where(selectionRaw, 'like', `%${compareValue}%`);
+    },
+});

package/dist/utils/apply-query/operators/ends-with.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/ends-with.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_ends_with',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.where(selectionRaw, 'like', `%${compareValue}`);
+    },
+});

package/dist/utils/apply-query/operators/equals.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/equals.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_eq',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.where(selectionRaw, '=', compareValue);
+    },
+});

package/dist/utils/apply-query/operators/greather-than-equals.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/greather-than-equals.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_gte',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.where(selectionRaw, '>=', compareValue);
+    },
+});

package/dist/utils/apply-query/operators/greather-than.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/greather-than.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_gt',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.where(selectionRaw, '>', compareValue);
+    },
+});

package/dist/utils/apply-query/operators/in.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/in.operator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_in',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        let value = compareValue;
+        if (typeof value === 'string')
+            value = value.split(',');
+        if (!(value instanceof Array))
+            throw new Error('Invalid value for in operator');
+        query.whereIn(selectionRaw, value);
+    },
+});

package/dist/utils/apply-query/operators/index.d.ts

@@ -0,0 +1,3 @@
+import { OperatorRegister } from './operator-register';
+declare const _default: Record<string, OperatorRegister>;
+export default _default;

package/dist/utils/apply-query/operators/index.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const between_operator_1 = __importDefault(require("./between.operator"));
+const contains_operator_1 = __importDefault(require("./contains.operator"));
+const ends_with_operator_1 = __importDefault(require("./ends-with.operator"));
+const equals_operator_1 = __importDefault(require("./equals.operator"));
+const greather_than_equals_operator_1 = __importDefault(require("./greather-than-equals.operator"));
+const greather_than_operator_1 = __importDefault(require("./greather-than.operator"));
+const in_operator_1 = __importDefault(require("./in.operator"));
+const insensitive_contains_operator_1 = __importDefault(require("./insensitive-contains.operator"));
+const insensitive_ends_with_operator_1 = __importDefault(require("./insensitive-ends-with.operator"));
+const insensitive_equals_operator_1 = __importDefault(require("./insensitive-equals.operator"));
+const insensitive_not_contains_operator_1 = __importDefault(require("./insensitive-not-contains.operator"));
+const insensitive_not_ends_with_operator_1 = __importDefault(require("./insensitive-not-ends-with.operator"));
+const insensitive_not_equals_operator_1 = __importDefault(require("./insensitive-not-equals.operator"));
+const insensitive_not_starts_with_operator_1 = __importDefault(require("./insensitive-not-starts-with.operator"));
+const insensitive_starts_with_operator_1 = __importDefault(require("./insensitive-starts-with.operator"));
+const intersects_bbox_operator_1 = __importDefault(require("./intersects-bbox.operator"));
+const intersects_operator_1 = __importDefault(require("./intersects.operator"));
+const is_empty_operator_1 = __importDefault(require("./is-empty.operator"));
+const is_not_empty_operator_1 = __importDefault(require("./is-not-empty.operator"));
+const is_not_null_operator_1 = __importDefault(require("./is-not-null.operator"));
+const is_null_operator_1 = __importDefault(require("./is-null.operator"));
+const less_than_equals_operator_1 = __importDefault(require("./less-than-equals.operator"));
+const less_than_operator_1 = __importDefault(require("./less-than.operator"));
+const not_between_operator_1 = __importDefault(require("./not-between.operator"));
+const not_contains_operator_1 = __importDefault(require("./not-contains.operator"));
+const not_ends_with_operator_1 = __importDefault(require("./not-ends-with.operator"));
+const not_equals_operator_1 = __importDefault(require("./not-equals.operator"));
+const not_in_operator_1 = __importDefault(require("./not-in.operator"));
+const not_intersects_bbox_operator_1 = __importDefault(require("./not-intersects-bbox.operator"));
+const not_intersects_operator_1 = __importDefault(require("./not-intersects.operator"));
+const not_starts_with_operator_1 = __importDefault(require("./not-starts-with.operator"));
+const starts_with_operator_1 = __importDefault(require("./starts-with.operator"));
+const operators = [
+    is_null_operator_1.default,
+    is_not_null_operator_1.default,
+    is_empty_operator_1.default,
+    is_not_empty_operator_1.default,
+    equals_operator_1.default,
+    not_equals_operator_1.default,
+    contains_operator_1.default,
+    not_contains_operator_1.default,
+    starts_with_operator_1.default,
+    not_starts_with_operator_1.default,
+    ends_with_operator_1.default,
+    not_ends_with_operator_1.default,
+    greather_than_operator_1.default,
+    greather_than_equals_operator_1.default,
+    less_than_operator_1.default,
+    less_than_equals_operator_1.default,
+    in_operator_1.default,
+    not_in_operator_1.default,
+    between_operator_1.default,
+    not_between_operator_1.default,
+    intersects_operator_1.default,
+    not_intersects_operator_1.default,
+    intersects_bbox_operator_1.default,
+    not_intersects_bbox_operator_1.default,
+    insensitive_contains_operator_1.default,
+    insensitive_not_contains_operator_1.default,
+    insensitive_equals_operator_1.default,
+    insensitive_not_equals_operator_1.default,
+    insensitive_starts_with_operator_1.default,
+    insensitive_not_starts_with_operator_1.default,
+    insensitive_ends_with_operator_1.default,
+    insensitive_not_ends_with_operator_1.default,
+];
+exports.default = operators.reduce((a, b) => ({ ...a, [b.operator]: b }), {});

package/dist/utils/apply-query/operators/insensitive-contains.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/insensitive-contains.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_icontains',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue === null || compareValue === void 0 ? void 0 : compareValue.toLowerCase()}%`]);
+    },
+});

package/dist/utils/apply-query/operators/insensitive-ends-with.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/insensitive-ends-with.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_iends_with',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereRaw(`LOWER(??) LIKE ?`, [selectionRaw, `%${compareValue === null || compareValue === void 0 ? void 0 : compareValue.toLowerCase()}`]);
+    },
+});

package/dist/utils/apply-query/operators/insensitive-equals.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;

package/dist/utils/apply-query/operators/insensitive-equals.operator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const operator_register_1 = require("./operator-register");
+exports.default = (0, operator_register_1.registerOperator)({
+    operator: '_ieq',
+    apply: ({ query, selectionRaw, compareValue }) => {
+        query.whereRaw(`LOWER(??) = ?`, [selectionRaw, `${compareValue === null || compareValue === void 0 ? void 0 : compareValue.toLowerCase()}`]);
+    },
+});

package/dist/utils/apply-query/operators/insensitive-not-contains.operator.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./operator-register").OperatorRegister;
+export default _default;