@autofleet/sadot 0.6.1-temp-2 → 0.6.1

package/dist/tests/api/test-api.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importStar(require("express"));
+const models_1 = require("../../models");
+const app = (0, express_1.default)();
+app.use(express_1.default.json());
+const api = (0, express_1.Router)();
+api.get('/v1/test-models', async (req, res) => {
+    const testModels = await models_1.TestModel.findAll();
+    return res.json(testModels);
+});
+api.get('/v1/test-models/:testModelId', async (req, res) => {
+    const { params: { testModelId } } = req;
+    const testModel = await models_1.TestModel.findByPk(testModelId);
+    return res.json(testModel);
+});
+api.post('/v1/test-models', async (req, res) => {
+    const { body } = req;
+    const testModel = await models_1.TestModel.create(body);
+    return res.json(testModel);
+});
+api.patch('/v1/test-models/:testModelId', async (req, res) => {
+    const { body, params: { testModelId } } = req;
+    const testModel = await models_1.TestModel.update(body, {
+        where: {
+            id: testModelId,
+        },
+        returning: true,
+    });
+    return res.json(testModel[1][0]);
+});
+app.use('/api', api);
+exports.default = app;

package/dist/tests/functional/searching/index.d.ts

@@ -0,0 +1,8 @@
+interface CustomFieldsSearchTestFlowInput {
+    fieldType: string;
+    fieldValue: string | number;
+    searchTerm: string;
+    expectedNumberOfQueryResults: number;
+}
+declare const customFieldsSearchTestFlow: ({ fieldType, fieldValue, searchTerm, expectedNumberOfQueryResults, }: CustomFieldsSearchTestFlowInput) => Promise<void>;
+export default customFieldsSearchTestFlow;

package/dist/tests/functional/searching/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../../index");
+const DefinitionRepo = __importStar(require("../../../repository/definition"));
+const definition_mock_1 = require("../../mocks/definition.mock");
+const testModel_1 = require("../../mocks/testModel");
+const models_1 = require("../../../models");
+const customFieldsSearchTestFlow = async ({ fieldType, fieldValue, searchTerm, expectedNumberOfQueryResults, }) => {
+    const definition = (0, definition_mock_1.createDefinition)({ fieldType, name: 'coolDefinition' });
+    await DefinitionRepo.create({ ...definition });
+    const [testModel1] = await (0, testModel_1.createTestModels)(definition.entityId, 2);
+    await testModel1.update({ customFields: { [definition.name]: fieldValue } });
+    const models = await models_1.TestModel.findAndCountAll({
+        ...(0, index_1.generateCustomFieldSearchQueryPayload)(searchTerm, models_1.TestModel, definition.entityId),
+    });
+    expect(models.count).toBe(expectedNumberOfQueryResults);
+    if (expectedNumberOfQueryResults > 0) {
+        expect(models.rows[0].dataValues.id).toBe(testModel1.id);
+    }
+};
+exports.default = customFieldsSearchTestFlow;

package/dist/tests/helpers/database-config.d.ts

@@ -0,0 +1,16 @@
+declare const _default: {
+    test: {
+        username: string;
+        password: string;
+        database: string;
+        host: string;
+        port: string | number;
+        dialect: string;
+        define: {
+            underscored: boolean;
+            underscoredAll: boolean;
+        };
+        logging: boolean;
+    };
+};
+export default _default;

package/dist/tests/helpers/database-config.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    test: {
+        username: process.env.DB_USERNAME || '',
+        password: process.env.DB_PASSWORD || null,
+        database: process.env.DB_NAME || 'sadot_package_test',
+        host: process.env.DB_HOST || '127.0.0.1',
+        port: process.env.DB_PORT || 5432,
+        dialect: process.env.DB_TYPE || 'postgres',
+        define: {
+            underscored: true,
+            underscoredAll: true,
+        },
+        logging: false,
+    },
+};

package/dist/tests/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export declare const cleanup: () => Promise<void>;
+export declare const getModel: (name: string) => any;

package/dist/tests/helpers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = exports.cleanup = void 0;
+const models_1 = require("../../models");
+// eslint-disable-next-line import/prefer-default-export
+const cleanup = async () => {
+    if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
+        await models_1.CustomFieldDefinition.unscoped().destroy({ where: {} });
+        await models_1.TestModel.destroy({ where: {} });
+        await models_1.ContextAwareTestModel.destroy({ where: {} });
+        await models_1.ContextTestModel.destroy({ where: {} });
+    }
+};
+exports.cleanup = cleanup;
+const getModel = (name) => {
+    // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+    const models = require('../../models');
+    return models[name];
+};
+exports.getModel = getModel;

package/dist/tests/mocks/definition.mock.d.ts

@@ -0,0 +1,43 @@
+import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+export declare const contextAwareFieldDefinition: {
+    name: string;
+    modelType: string;
+    fieldType: string;
+    entityType: string;
+};
+export declare const coolFieldDefinition: CreateCustomFieldDefinition;
+export declare const coolFieldDefinition2: {
+    name: string;
+    required?: boolean;
+    disabled?: boolean;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    displayName?: string;
+    validation?: any;
+    fieldType: string;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+};
+export declare const coolFieldDefinition3: {
+    name: string;
+    required?: boolean;
+    disabled?: boolean;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    displayName?: string;
+    validation?: any;
+    fieldType: string;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+};
+export declare const booleanField: (modelType: string) => CreateCustomFieldDefinition;
+export declare const enumField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const rangeField: (modelType: string) => CreateCustomFieldDefinition;
+export declare const createDefinition: (defaults: Partial<CustomFieldDefinitionDTO>) => CreateCustomFieldDefinition;
+export declare const createDefinitions: (defaults: Partial<CustomFieldDefinitionDTO>, length?: number) => CreateCustomFieldDefinition[];

package/dist/tests/mocks/definition.mock.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefinitions = exports.createDefinition = exports.rangeField = exports.enumField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
+const uuid_1 = require("uuid");
+exports.contextAwareFieldDefinition = {
+    name: 'cool field',
+    modelType: 'ContextAwareTestModel',
+    fieldType: 'number',
+    entityType: 'fleetId',
+};
+exports.coolFieldDefinition = {
+    name: 'cool field',
+    modelType: 'TestModel',
+    fieldType: 'number',
+    entityId: (0, uuid_1.v4)(),
+    entityType: 'fleetId',
+};
+exports.coolFieldDefinition2 = {
+    ...exports.coolFieldDefinition,
+    name: 'cool field2',
+};
+exports.coolFieldDefinition3 = {
+    ...exports.coolFieldDefinition,
+    name: 'cool field3',
+};
+const booleanField = (modelType) => ({
+    name: 'shapeless',
+    modelType,
+    fieldType: 'boolean',
+    entityId: (0, uuid_1.v4)(),
+    entityType: 'fleetId',
+});
+exports.booleanField = booleanField;
+const enumField = (modelType, options) => ({
+    name: 'choices',
+    modelType,
+    fieldType: 'select',
+    validation: options,
+    entityId: (0, uuid_1.v4)(),
+    entityType: 'fleetId',
+});
+exports.enumField = enumField;
+const rangeField = (modelType) => ({
+    name: 'ranges',
+    modelType,
+    fieldType: 'number',
+    validation: {
+        between: [10, 12],
+    },
+    entityId: (0, uuid_1.v4)(),
+    entityType: 'fleetId',
+});
+exports.rangeField = rangeField;
+// eslint-disable-next-line max-len
+const createDefinition = (defaults) => ({
+    name: defaults?.name || `def_${(0, uuid_1.v4)()}`,
+    modelType: defaults?.modelType || 'TestModel',
+    fieldType: defaults?.fieldType || 'boolean',
+    entityId: defaults?.entityId || (0, uuid_1.v4)(),
+    entityType: defaults?.entityType || 'fleetId',
+});
+exports.createDefinition = createDefinition;
+const createDefinitions = (defaults, length = 1) => (Array(length).fill({}).map((_) => ({
+    name: defaults?.name || `def_${(0, uuid_1.v4)()}`,
+    modelType: defaults?.modelType || 'TestModel',
+    fieldType: defaults?.fieldType || 'boolean',
+    entityId: defaults?.entityId || (0, uuid_1.v4)(),
+    entityType: defaults?.entityType || 'fleetId',
+})));
+exports.createDefinitions = createDefinitions;

package/dist/tests/mocks/events.mock.d.ts

@@ -0,0 +1,3 @@
+export declare const mockEvent: (events: any, eventName: any, numberOfEvents: any) => any[];
+export declare const mockDimCustomFieldDefinitionEvent: (events: any, numberOfEvents: any) => any[];
+export declare const mockDimCustomFieldValueEvent: (events: any, numberOfEvents: any) => any[];

package/dist/tests/mocks/events.mock.js

@@ -0,0 +1,19 @@
+"use strict";
+/* eslint-disable no-param-reassign */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockDimCustomFieldValueEvent = exports.mockDimCustomFieldDefinitionEvent = exports.mockEvent = void 0;
+const mockEvent = (events, eventName, numberOfEvents) => {
+    events.sendObject = jest.fn();
+    return [
+        events.sendObject,
+        () => {
+            const matchingEvents = events.sendObject.mock.calls.filter((call) => call[0] === eventName);
+            expect(matchingEvents.length).toEqual(numberOfEvents);
+        },
+    ];
+};
+exports.mockEvent = mockEvent;
+const mockDimCustomFieldDefinitionEvent = (events, numberOfEvents) => (0, exports.mockEvent)(events, 'dim_custom_field_definition', numberOfEvents);
+exports.mockDimCustomFieldDefinitionEvent = mockDimCustomFieldDefinitionEvent;
+const mockDimCustomFieldValueEvent = (events, numberOfEvents) => (0, exports.mockEvent)(events, 'dim_custom_field_value', numberOfEvents);
+exports.mockDimCustomFieldValueEvent = mockDimCustomFieldValueEvent;

package/dist/tests/mocks/testModel.d.ts

@@ -0,0 +1,12 @@
+import { TestModel } from '../../models';
+export declare const createTestModel: (payload?: {}) => Promise<TestModel>;
+export declare const createTestModels: (fleetId: any, total: number) => Promise<TestModel[]>;
+export declare const upsertTestModel: (payload: any) => Promise<[TestModel, boolean]>;
+export declare const destroyTestModels: () => Promise<number>;
+export declare const getTestModel: (id: string, options?: {}) => Promise<TestModel | null>;
+export declare const getSomeTestModels: (options?: {
+    limit: number;
+}) => Promise<TestModel[]>;
+export declare const updateTestModel: (payload: any, query: any) => Promise<[affectedCount: number, affectedRows: TestModel[]]>;
+export declare const createTestModelWithAssociation: () => Promise<TestModel>;
+export declare const getTestModelWithAssociation: (limit?: number) => Promise<TestModel[]>;

package/dist/tests/mocks/testModel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestModelWithAssociation = exports.createTestModelWithAssociation = exports.updateTestModel = exports.getSomeTestModels = exports.getTestModel = exports.destroyTestModels = exports.upsertTestModel = exports.createTestModels = exports.createTestModel = void 0;
+const models_1 = require("../../models");
+const createTestModel = (payload = {}) => models_1.TestModel.create(payload);
+exports.createTestModel = createTestModel;
+const createTestModels = (fleetId, total) => {
+    const models = [];
+    for (let i = 0; i < total; i += 1) {
+        models.push((0, exports.createTestModel)({ fleetId }));
+    }
+    return Promise.all(models);
+};
+exports.createTestModels = createTestModels;
+const upsertTestModel = (payload) => models_1.TestModel.upsert(payload);
+exports.upsertTestModel = upsertTestModel;
+const destroyTestModels = () => models_1.TestModel.destroy({ truncate: true });
+exports.destroyTestModels = destroyTestModels;
+const getTestModel = (id, options = {}) => models_1.TestModel.findByPk(id, options);
+exports.getTestModel = getTestModel;
+const getSomeTestModels = (options = { limit: 1 }) => models_1.TestModel.findAll(options);
+exports.getSomeTestModels = getSomeTestModels;
+const updateTestModel = (payload, query) => models_1.TestModel.update(payload, query);
+exports.updateTestModel = updateTestModel;
+// Associations
+const createTestModelWithAssociation = async () => {
+    const model = await models_1.TestModel.create({});
+    await models_1.AssociatedTestModel.create({ testModelId: model.id });
+    return model;
+};
+exports.createTestModelWithAssociation = createTestModelWithAssociation;
+const getTestModelWithAssociation = (limit = 1) => models_1.TestModel.findAll({
+    limit, include: [models_1.AssociatedTestModel],
+});
+exports.getTestModelWithAssociation = getTestModelWithAssociation;

package/dist/types/definition/index.d.ts

@@ -0,0 +1,23 @@
+export interface CustomFieldDefinitionDTO {
+    id: string;
+    name: string;
+    displayName?: string;
+    validation?: any;
+    fieldType: string;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+    required?: boolean;
+    description?: string;
+    disabled?: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+}
+export type CreateCustomFieldDefinition = Omit<CustomFieldDefinitionDTO, 'id'>;
+export type UpdateCustomFieldDefinition = Partial<CreateCustomFieldDefinition>;
+export type SerializedCustomFields = {
+    [name: string]: CustomFieldDefinitionDTO & {
+        value: any;
+    };
+};

package/dist/types/definition/index.js

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

package/dist/types/index.d.ts

@@ -0,0 +1,31 @@
+import { IncludeOptions } from 'sequelize';
+import { ModelCtor } from 'sequelize-typescript';
+export type ModelFetcher = (name: string) => any;
+export type ModelOptions = {
+    /**
+     * Include options for the model
+     */
+    include?: (entityIds: string[]) => IncludeOptions[];
+    /**
+      * Custom association for the model
+      * @param model - The model to associate with
+     */
+    customAssociation?: (model: ModelCtor) => void;
+    /**
+     * Whether to use the entity id  from the instance per scope attribute
+     */
+    useEntityIdFromInclude?: boolean;
+};
+export type Models = {
+    name: string;
+    scopeAttributes: any[];
+    modelOptions?: ModelOptions;
+    creationWebhookHandler?: (instance: any) => any;
+    updateWebhookHandler?: (instance: any) => any;
+    deletionWebhookHandler?: (instance: any) => any;
+};
+export type CustomFieldOptions = {
+    models: Models[];
+    databaseConfig: any;
+    getUser: () => any;
+};

package/dist/types/index.js

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

package/dist/types/value/index.d.ts

@@ -0,0 +1,15 @@
+export interface CustomFieldValueDTO {
+    id?: string;
+    modelId: string;
+    customFieldDefinitionId: string;
+    value: any;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+}
+export type ValuesToUpdate = {
+    [name: string]: any;
+};
+export type CreateCustomFieldValue = Omit<CustomFieldValueDTO, 'id'>;
+export type UpdateCustomFieldValue = ValuesToUpdate;
+export type BulkUpdateCustomFieldValue = Partial<CustomFieldValueDTO>[];

package/dist/types/value/index.js

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

package/dist/utils/constants/index.d.ts

@@ -0,0 +1,5 @@
+declare const CUSTOM_FIELDS_FILTER_SCOPE: string;
+export declare const supportedEntities: string[];
+export { 
+/** @deprecated Use the value from `@autofleet/common-types` instead */
+CUSTOM_FIELDS_FILTER_SCOPE, };

package/dist/utils/constants/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_FIELDS_FILTER_SCOPE = exports.supportedEntities = void 0;
+const common_types_1 = require("@autofleet/common-types");
+const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
+exports.CUSTOM_FIELDS_FILTER_SCOPE = CUSTOM_FIELDS_FILTER_SCOPE;
+// eslint-disable-next-line import/prefer-default-export
+exports.supportedEntities = ['businessModelId', 'fleetId', 'demandSourceId'];

package/dist/utils/db/index.d.ts

@@ -0,0 +1,4 @@
+import { Sequelize } from 'sequelize-typescript';
+declare const _default: (databaseConfig: any) => Sequelize;
+export default _default;
+export declare const createSequelizeMeta: (sequelize: Sequelize) => Promise<object[]>;

package/dist/utils/db/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSequelizeMeta = void 0;
+const sequelize_typescript_1 = require("sequelize-typescript");
+const sequelize_1 = require("sequelize");
+exports.default = (databaseConfig) => {
+    const ENV_DEV = 'test';
+    const env = process.env.NODE_ENV || ENV_DEV;
+    const config = databaseConfig[env];
+    let sequelize;
+    if (config.use_env_variable) {
+        sequelize = new sequelize_typescript_1.Sequelize(process.env[config.use_env_variable], config);
+    }
+    else {
+        sequelize = new sequelize_typescript_1.Sequelize(config.database, config.username, config.password, config);
+    }
+    return sequelize;
+};
+const createSequelizeMeta = (sequelize) => sequelize.query(`
+CREATE TABLE IF NOT EXISTS "SequelizeMeta" (
+  name character varying(255) PRIMARY KEY
+);
+`, { type: sequelize_1.QueryTypes.SELECT });
+exports.createSequelizeMeta = createSequelizeMeta;

package/dist/utils/helpers/index.d.ts

@@ -0,0 +1,25 @@
+import { WhereOptions, BindOrReplacements } from 'sequelize';
+import { ModelStatic } from 'sequelize-typescript';
+import { CustomFieldDefinitionType } from '../validations/type';
+/**
+ * Builds a WHERE clause and replacements for free-text search by custom fields.
+ *
+ * This function constructs a WHERE clause and replacement bindings that allow searching
+ * for a given term within custom fields associated with a specific model type and entity ID.
+ * The WHERE clause and replacements are designed to be added to the main query.
+ *
+ * @param {string} searchTerm - The term to search for within custom fields.
+ * @param {ModelStatic} model - The Sequelize model representing the entity type to search for.
+ * @param {string} entityId - The entity ID to filter the custom fields by.
+ * @param {CustomFieldDefinitionType[]} excludedCustomFieldsTypes - An array of custom field types
+ * to exclude from the search
+ *
+ * @returns {CustomFieldsSearchPayload} - An object containing the WHERE clause and replacements
+ * for Sequelize.
+ */
+interface CustomFieldsSearchPayload {
+    where: WhereOptions;
+    replacements: BindOrReplacements;
+}
+export declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;
+export {};

package/dist/utils/helpers/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCustomFieldSearchQueryPayload = void 0;
+/* eslint-disable import/prefer-default-export */
+const sequelize_1 = require("sequelize");
+const sequelize_typescript_1 = require("sequelize-typescript");
+const type_1 = require("../validations/type");
+const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
+    type_1.CustomFieldDefinitionType.DATETIME,
+    type_1.CustomFieldDefinitionType.DATE,
+]) => {
+    const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(',');
+    const subQuery = 'EXISTS ('
+        + ' SELECT 1'
+        + ' FROM "custom_field_values" AS "cv"'
+        + ' INNER JOIN custom_field_definitions AS cd '
+        + ` ON cd.entity_id = '${entityId}'`
+        + ' AND cv.custom_field_definition_id = cd.id'
+        + ` AND cd.model_type = '${model.name}'`
+        + ` ${excludedTypesString ? `AND cd.field_type NOT IN (${excludedTypesString})` : ''}`
+        + ' WHERE'
+        + ' "cv"."deleted_at" IS NULL'
+        + ` AND "cv"."model_id" = "${model.name}"."id"`
+        + ' AND CAST("cv"."value" AS TEXT) ILIKE :searchTerm)';
+    return {
+        where: {
+            [sequelize_1.Op.or]: [
+                sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.literal(subQuery), true),
+            ],
+        },
+        replacements: { searchTerm: `%${searchTerm}%` },
+    };
+};
+exports.generateCustomFieldSearchQueryPayload = generateCustomFieldSearchQueryPayload;

package/dist/utils/init.d.ts

@@ -0,0 +1,5 @@
+import type { ModelFetcher, Models } from '../types';
+export declare const addHooks: (models: Models[], getModel: ModelFetcher) => void;
+export declare const removeHooks: (models: Models[], getModel: ModelFetcher) => void;
+export declare const addScopes: (models: Models[], getModel: ModelFetcher) => void;
+export declare const applyCustomAssociation: (models: Models[]) => void;