@autofleet/sadot 0.3.3 → 0.4.2

package/.nvmrc

@@ -0,0 +1 @@
+18.17.1

package/dist/api/v1/errors.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (err: any, res: any, additionalData?: {}) => any;
+declare const _default: (err: any, res: any, additionalData?: any) => Promise<any>;
 export default _default;

package/dist/api/v1/errors.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("@autofleet/errors");
 const joi_1 = require("@hapi/joi");
 const sequelize_1 = require("sequelize");
-exports.default = (err, res, additionalData = {}) => {
+exports.default = (err, res, additionalData = undefined) => {
     let error = err;
     if (err instanceof joi_1.ValidationError) {
         error = new errors_1.BadRequest([err], null);

package/dist/hooks/find.js

@@ -17,7 +17,7 @@ const doScopeAttributesMissing = (scopeAttributes, queryAttributes) => {
 // eslint-disable-next-line import/prefer-default-export
 const beforeFind = (scopeAttributes) => (options) => {
     const { attributes: queryAttributes } = options;
-    if (queryAttributes?.includes('customFields')) {
+    if (queryAttributes?.includes?.('customFields')) {
         const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
         logger_1.default.debug('sadot - before find hook');
         if (missingScopeAttributes?.length > 0) {

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import type { Application } from 'express';
 import { Sequelize } from 'sequelize-typescript';
-import { CustomFieldOptions, ModelFetcher } from './types';
+import type { CustomFieldOptions, ModelFetcher } from './types';
 export * from './utils/validations/custom-fields';
+export * from './utils/constants';
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
  * @see {@link 'custom-fields/config'} for configurations

package/dist/index.js

@@ -18,44 +18,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.disableCustomFields = void 0;
-const sequelize_1 = require("sequelize");
 const models_1 = require("./models");
 const api_1 = __importDefault(require("./api"));
-const hooks_1 = require("./hooks");
 const db_1 = __importDefault(require("./utils/db"));
 const logger_1 = __importDefault(require("./utils/logger"));
+const init_1 = require("./utils/init");
 __exportStar(require("./utils/validations/custom-fields"), exports);
-const addHooks = (models, getModel) => {
-    models.forEach(async ({ name, scopeAttributes }) => {
-        try {
-            const model = getModel(name);
-            if (!model) {
-                logger_1.default.warn('sadot - tried to addHooks to a model that does not exist yet', {
-                    name,
-                    scopeAttributes,
-                });
-                return;
-            }
-            model.rawAttributes.customFields = {
-                type: sequelize_1.DataTypes.VIRTUAL,
-            };
-            model.refreshAttributes();
-            // TODO: Uncomment after tests are passed
-            // model.addHook('afterFind', workaround);
-            model.addHook('beforeFind', 'sadot-beforeFind', (0, hooks_1.beforeFind)(scopeAttributes));
-            model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', hooks_1.beforeBulkCreate);
-            model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', hooks_1.beforeBulkUpdate);
-            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes));
-            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes));
-            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes));
-            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes));
-            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes));
-        }
-        catch (e) {
-            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
-        }
-    });
-};
+__exportStar(require("./utils/constants"), exports);
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
  * @see {@link 'custom-fields/config'} for configurations
@@ -69,37 +38,15 @@ const useCustomFields = async (app, getModel, options) => {
     if (process.env.NODE_ENV === 'test') {
         await (0, models_1.initTestModels)(sequelize);
     }
-    addHooks(models, getModel);
+    // The order is important
+    (0, init_1.addHooks)(models, getModel);
     await (0, models_1.initTables)(sequelize, options.getUser);
+    (0, init_1.addScopes)(models, getModel);
     logger_1.default.debug('sadot - custom fields finished initializing with models', models);
     return sequelize;
 };
 exports.default = useCustomFields;
-const removeHooks = (models, getModel) => {
-    models.forEach(async ({ name }) => {
-        try {
-            const model = getModel(name);
-            if (!model)
-                return;
-            if (model.rawAttributes.customFields) {
-                delete model.rawAttributes.customFields;
-                model.refreshAttributes();
-            }
-            // model.removeHook('afterFind', 'sadot-workaround');
-            model.removeHook('beforeFind', 'sadot-beforeFind');
-            model.removeHook('beforeBulkCreate', 'sadot-beforeBulkCreate');
-            model.removeHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate');
-            model.removeHook('beforeCreate', 'sadot-beforeCreate');
-            model.removeHook('beforeUpdate', 'sadot-beforeUpdate');
-            model.removeHook('afterFind', 'sadot-afterFind');
-            model.removeHook('afterUpdate', 'sadot-afterUpdate');
-        }
-        catch (e) {
-            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
-        }
-    });
-};
 const disableCustomFields = (models, getModel) => {
-    removeHooks(models, getModel);
+    (0, init_1.removeHooks)(models, getModel);
 };
 exports.disableCustomFields = disableCustomFields;

package/dist/models/tests/TestModel.d.ts

@@ -7,5 +7,6 @@ declare class TestModel extends Model {
     demandSourceId: string;
     coolAttribute?: boolean;
     associatedModels: AssociatedTestModel[];
+    customFields?: any;
 }
 export default TestModel;

package/dist/models/tests/TestModel.js

@@ -57,6 +57,12 @@ __decorate([
     (0, sequelize_typescript_1.HasMany)(() => AssociatedTestModel_1.default),
     __metadata("design:type", Array)
 ], TestModel.prototype, "associatedModels", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.VIRTUAL,
+    }),
+    __metadata("design:type", Object)
+], TestModel.prototype, "customFields", void 0);
 TestModel = __decorate([
     (0, sequelize_typescript_1.Table)({ schema: 'custom-fields', createdAt: false, updatedAt: false })
 ], TestModel);

package/dist/scopes/filter.d.ts

@@ -0,0 +1,23 @@
+import { WhereOptions } from 'sequelize';
+/**
+ * Type representing possible condition values.
+ * Currently supporting strings and arrays of strings.
+ * More types to be added (TBA).
+ */
+export type ConditionValue = string | string[];
+export type CustomFieldSort = {
+    field: string;
+    direction: 'ASC' | 'DESC';
+};
+export type CustomFieldFilterOptions = {
+    where?: WhereOptions;
+};
+/**
+ * A Sequelize scope for filtering models by custom fields.
+ * This scope builds a WHERE clause to be applied on the main query.
+ *
+ * @param {string} name - The model type name used to join custom_field_definitions.
+ * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
+ */
+export declare const customFieldsFilterScope: (name: string) => (conditions: Record<string, ConditionValue>) => CustomFieldFilterOptions;
+export declare const scopeName = "filterByCustomFields";

package/dist/scopes/filter.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopeName = exports.customFieldsFilterScope = void 0;
+/* eslint-disable import/prefer-default-export */
+const sequelize_1 = require("sequelize");
+const sequelize_typescript_1 = require("sequelize-typescript");
+const constants_1 = require("../utils/constants");
+/**
+ * A Sequelize scope for filtering models by custom fields.
+ * This scope builds a WHERE clause to be applied on the main query.
+ *
+ * @param {string} name - The model type name used to join custom_field_definitions.
+ * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
+ */
+const customFieldsFilterScope = (name) => (conditions) => {
+    // Build the WHERE clause for custom field filtering
+    const customFieldConditions = Object.entries(conditions)
+        .map(([key, value]) => {
+        if (Array.isArray(value)) {
+            const values = value.map((v) => `'${v}'`).join(',');
+            return `custom_fields->>'${key}' IN (${values})`;
+        }
+        return `custom_fields->>'${key}' = '${value}'`;
+    })
+        .join(' AND ');
+    const subQuery = `${'SELECT model_id FROM ('
+        + 'SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields '
+        + 'FROM custom_field_values AS cv '
+        + 'INNER JOIN custom_field_definitions AS cd ON cv.custom_field_definition_id = cd.id '
+        + `AND cd.model_type = '${name}' `
+        + 'GROUP BY cv.model_id'
+        + ') AS CustomFieldAggregation '
+        + 'WHERE '}${customFieldConditions}`;
+    return {
+        where: {
+            id: {
+                [sequelize_1.Op.in]: sequelize_typescript_1.Sequelize.literal(`(${subQuery})`),
+            },
+        },
+    };
+};
+exports.customFieldsFilterScope = customFieldsFilterScope;
+exports.scopeName = constants_1.CUSTOM_FIELDS_FILTER_SCOPE;

package/dist/scopes/index.d.ts

@@ -0,0 +1,2 @@
+import { customFieldsFilterScope } from './filter';
+export { customFieldsFilterScope, };

package/dist/scopes/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customFieldsFilterScope = void 0;
+/* eslint-disable import/prefer-default-export */
+const filter_1 = require("./filter");
+Object.defineProperty(exports, "customFieldsFilterScope", { enumerable: true, get: function () { return filter_1.customFieldsFilterScope; } });

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

@@ -1,7 +1,7 @@
 declare const _default: {
     test: {
         username: string;
-        password: string | null;
+        password: string;
         database: string;
         host: string;
         dialect: string;

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

@@ -2,13 +2,13 @@ import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../typ
 export declare const coolFieldDefinition: CreateCustomFieldDefinition;
 export declare const coolFieldDefinition2: {
     name: string;
-    required?: boolean | undefined;
-    disabled?: boolean | undefined;
-    description?: string | undefined;
-    createdAt?: Date | undefined;
-    updatedAt?: Date | undefined;
-    deletedAt?: Date | undefined;
-    displayName?: string | undefined;
+    required?: boolean;
+    disabled?: boolean;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    displayName?: string;
     validation?: any;
     fieldType: string;
     entityId: string;
@@ -17,13 +17,13 @@ export declare const coolFieldDefinition2: {
 };
 export declare const coolFieldDefinition3: {
     name: string;
-    required?: boolean | undefined;
-    disabled?: boolean | undefined;
-    description?: string | undefined;
-    createdAt?: Date | undefined;
-    updatedAt?: Date | undefined;
-    deletedAt?: Date | undefined;
-    displayName?: string | undefined;
+    required?: boolean;
+    disabled?: boolean;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    displayName?: string;
     validation?: any;
     fieldType: string;
     entityId: string;

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

@@ -1,7 +1,7 @@
 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 | null]>;
+export declare const upsertTestModel: (payload: any) => Promise<[TestModel, boolean]>;
 export declare const destroyTestModels: () => Promise<number>;
 export declare const getTestModel: (id: string, options?: {}) => Promise<TestModel>;
 export declare const getSomeTestModels: (options?: {

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

@@ -1 +1,2 @@
 export declare const supportedEntities: string[];
+export declare const CUSTOM_FIELDS_FILTER_SCOPE = "filterByCustomFields";

package/dist/utils/constants/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.supportedEntities = void 0;
+exports.CUSTOM_FIELDS_FILTER_SCOPE = exports.supportedEntities = void 0;
 // eslint-disable-next-line import/prefer-default-export
 exports.supportedEntities = ['businessModelId', 'fleetId', 'demandSourceId'];
+exports.CUSTOM_FIELDS_FILTER_SCOPE = 'filterByCustomFields';

package/dist/utils/init.d.ts

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

package/dist/utils/init.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
+const sequelize_1 = require("sequelize");
+const models_1 = require("../models");
+const hooks_1 = require("../hooks");
+const scopes_1 = require("../scopes");
+const logger_1 = __importDefault(require("./logger"));
+const constants_1 = require("./constants");
+const addHooks = (models, getModel) => {
+    models.forEach(async ({ name, scopeAttributes }) => {
+        try {
+            const model = getModel(name);
+            if (!model) {
+                logger_1.default.warn('sadot - tried to addHooks to a model that does not exist yet', {
+                    name,
+                    scopeAttributes,
+                });
+                return;
+            }
+            model.rawAttributes.customFields = {
+                type: sequelize_1.DataTypes.VIRTUAL,
+            };
+            model.refreshAttributes();
+            // TODO: Uncomment after tests are passed
+            // model.addHook('afterFind', workaround);
+            model.addHook('beforeFind', 'sadot-beforeFind', (0, hooks_1.beforeFind)(scopeAttributes));
+            model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', hooks_1.beforeBulkCreate);
+            model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', hooks_1.beforeBulkUpdate);
+            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes));
+            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes));
+            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes));
+            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes));
+            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes));
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
+        }
+    });
+};
+exports.addHooks = addHooks;
+const removeHooks = (models, getModel) => {
+    models.forEach(async ({ name }) => {
+        try {
+            const model = getModel(name);
+            if (!model)
+                return;
+            if (model.rawAttributes.customFields) {
+                delete model.rawAttributes.customFields;
+                model.refreshAttributes();
+            }
+            // model.removeHook('afterFind', 'sadot-workaround');
+            model.removeHook('beforeFind', 'sadot-beforeFind');
+            model.removeHook('beforeBulkCreate', 'sadot-beforeBulkCreate');
+            model.removeHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate');
+            model.removeHook('beforeCreate', 'sadot-beforeCreate');
+            model.removeHook('beforeUpdate', 'sadot-beforeUpdate');
+            model.removeHook('afterFind', 'sadot-afterFind');
+            model.removeHook('afterUpdate', 'sadot-afterUpdate');
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
+        }
+    });
+};
+exports.removeHooks = removeHooks;
+/**
+ *  Necessary associations for the {@link customFieldsFilterScope} scope
+ */
+const addAssociations = (model, modelName) => {
+    model.hasMany(models_1.CustomFieldValue, { foreignKey: 'modelId', as: 'customFieldValue' });
+    // TBC: maybe can be removed
+    models_1.CustomFieldValue.belongsTo(model, { foreignKey: 'modelId', as: modelName });
+};
+const addScopes = (models, getModel) => {
+    models.forEach(async ({ name, scopeAttributes }) => {
+        try {
+            const model = getModel(name);
+            if (!model) {
+                logger_1.default.warn('sadot - tried to addScopes to a model that does not exist yet', {
+                    name,
+                    scopeAttributes,
+                });
+                return;
+            }
+            // Necessary associations for the filtering scope
+            addAssociations(model, name);
+            // Add filter scope
+            model.addScope(constants_1.CUSTOM_FIELDS_FILTER_SCOPE, (0, scopes_1.customFieldsFilterScope)(name));
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields scopes to model ${name}. `, e);
+        }
+    });
+};
+exports.addScopes = addScopes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.3.3",
+  "version": "0.4.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -26,6 +26,7 @@
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/jest": "^27.0.9",
+    "@types/uuid": "^9.0.2",
     "@typescript-eslint/eslint-plugin": "^4.8.1",
     "@typescript-eslint/parser": "^4.33.0",
     "eslint": "^7.13.0",

package/src/api/v1/errors.ts

@@ -2,7 +2,7 @@ import { handleError, BadRequest } from '@autofleet/errors';
 import { ValidationError as InputValidationError } from '@hapi/joi';
 import { ValidationError as DatabaseValidationError } from 'sequelize';
 
-export default (err, res, additionalData = {}) => {
+export default (err, res, additionalData = undefined) => {
   let error = err;
   if (err instanceof InputValidationError) {
     error = new BadRequest([err], null);

package/src/hooks/find.ts

@@ -16,7 +16,7 @@ const doScopeAttributesMissing = (
 // eslint-disable-next-line import/prefer-default-export
 export const beforeFind = (scopeAttributes: string[]) => (options): void => {
   const { attributes: queryAttributes } = options;
-  if (queryAttributes?.includes('customFields')) {
+  if (queryAttributes?.includes?.('customFields')) {
     const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
     logger.debug('sadot - before find hook');
     if (missingScopeAttributes?.length > 0) {

package/src/index.ts

@@ -1,52 +1,17 @@
 import type { Application } from 'express';
-import { DataTypes } from 'sequelize';
 import { Sequelize } from 'sequelize-typescript';
-import { initTables, initTestModels } from './models';
-import api from './api';
 import {
-  beforeFind,
-  enrichResults,
-  beforeBulkUpdate,
-  beforeUpdate,
-  beforeCreate,
-  beforeBulkCreate,
-} from './hooks';
+  initTables, initTestModels,
+} from './models';
+import api from './api';
 import initDB from './utils/db';
 import logger from './utils/logger';
-import { CustomFieldOptions, ModelFetcher, ModelOptions } from './types';
+import type { CustomFieldOptions, ModelFetcher } from './types';
+import { addHooks, addScopes, removeHooks } from './utils/init';
 
 export * from './utils/validations/custom-fields';
 
-const addHooks = (models: ModelOptions[], getModel: ModelFetcher) => {
-  models.forEach(async ({ name, scopeAttributes }) => {
-    try {
-      const model = getModel(name);
-      if (!model) {
-        logger.warn('sadot - tried to addHooks to a model that does not exist yet', {
-          name,
-          scopeAttributes,
-        });
-        return;
-      }
-      model.rawAttributes.customFields = {
-        type: DataTypes.VIRTUAL,
-      };
-      model.refreshAttributes();
-      // TODO: Uncomment after tests are passed
-      // model.addHook('afterFind', workaround);
-      model.addHook('beforeFind', 'sadot-beforeFind', beforeFind(scopeAttributes));
-      model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', beforeBulkCreate);
-      model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', beforeBulkUpdate);
-      model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes));
-      model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes));
-      model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes));
-      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes));
-      model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes));
-    } catch (e) {
-      logger.error(`Could not add custom fields hook to model ${name}. `, e);
-    }
-  });
-};
+export * from './utils/constants';
 
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
@@ -65,37 +30,16 @@ const useCustomFields = async (
   if (process.env.NODE_ENV === 'test') {
     await initTestModels(sequelize);
   }
+  // The order is important
   addHooks(models, getModel);
   await initTables(sequelize, options.getUser);
+  addScopes(models, getModel);
   logger.debug('sadot - custom fields finished initializing with models', models);
   return sequelize;
 };
 
 export default useCustomFields;
 
-const removeHooks = (models: ModelOptions[], getModel: ModelFetcher) => {
-  models.forEach(async ({ name }) => {
-    try {
-      const model = getModel(name);
-      if (!model) return;
-      if (model.rawAttributes.customFields) {
-        delete model.rawAttributes.customFields;
-        model.refreshAttributes();
-      }
-      // model.removeHook('afterFind', 'sadot-workaround');
-      model.removeHook('beforeFind', 'sadot-beforeFind');
-      model.removeHook('beforeBulkCreate', 'sadot-beforeBulkCreate');
-      model.removeHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate');
-      model.removeHook('beforeCreate', 'sadot-beforeCreate');
-      model.removeHook('beforeUpdate', 'sadot-beforeUpdate');
-      model.removeHook('afterFind', 'sadot-afterFind');
-      model.removeHook('afterUpdate', 'sadot-afterUpdate');
-    } catch (e) {
-      logger.error(`Could not add custom fields hook to model ${name}. `, e);
-    }
-  });
-};
-
-export const disableCustomFields = (models, getModel) => {
+export const disableCustomFields = (models, getModel): void => {
   removeHooks(models, getModel);
 };

package/src/models/tests/TestModel.ts

@@ -44,6 +44,11 @@ class TestModel extends Model {
 
   @HasMany(() => AssociatedTestModel)
   associatedModels: AssociatedTestModel[];
+
+  @Column({
+    type: DataType.VIRTUAL,
+  })
+  customFields?: any;
 }
 
 export default TestModel;

package/src/scopes/filter.ts

@@ -0,0 +1,63 @@
+/* eslint-disable import/prefer-default-export */
+import { Op, WhereOptions } from 'sequelize';
+import { Sequelize } from 'sequelize-typescript';
+import { CUSTOM_FIELDS_FILTER_SCOPE } from '../utils/constants';
+
+/**
+ * Type representing possible condition values.
+ * Currently supporting strings and arrays of strings.
+ * More types to be added (TBA).
+ */
+export type ConditionValue = string | string[];
+
+export type CustomFieldSort = {
+    field: string;
+    direction: 'ASC' | 'DESC';
+}
+
+export type CustomFieldFilterOptions = {
+  where?: WhereOptions;
+}
+
+/**
+ * A Sequelize scope for filtering models by custom fields.
+ * This scope builds a WHERE clause to be applied on the main query.
+ *
+ * @param {string} name - The model type name used to join custom_field_definitions.
+ * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
+ */
+export const customFieldsFilterScope = (
+  name: string,
+) => (conditions: Record<string, ConditionValue>): CustomFieldFilterOptions => {
+  // Build the WHERE clause for custom field filtering
+  const customFieldConditions = Object.entries(conditions)
+    .map(
+      ([key, value]) => {
+        if (Array.isArray(value)) {
+          const values = value.map((v) => `'${v}'`).join(',');
+          return `custom_fields->>'${key}' IN (${values})`;
+        }
+        return `custom_fields->>'${key}' = '${value}'`;
+      },
+    )
+    .join(' AND ');
+
+  const subQuery = `${'SELECT model_id FROM ('
+    + 'SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields '
+    + 'FROM custom_field_values AS cv '
+    + 'INNER JOIN custom_field_definitions AS cd ON cv.custom_field_definition_id = cd.id '
+    + `AND cd.model_type = '${name}' `
+    + 'GROUP BY cv.model_id'
+    + ') AS CustomFieldAggregation '
+    + 'WHERE '}${customFieldConditions}`;
+
+  return {
+    where: {
+      id: {
+        [Op.in]: Sequelize.literal(`(${subQuery})`),
+      },
+    },
+  };
+};
+
+export const scopeName = CUSTOM_FIELDS_FILTER_SCOPE;

package/src/scopes/index.ts

@@ -0,0 +1,6 @@
+/* eslint-disable import/prefer-default-export */
+import { customFieldsFilterScope } from './filter';
+
+export {
+  customFieldsFilterScope,
+};

package/src/utils/constants/index.ts

@@ -1,2 +1,4 @@
 // eslint-disable-next-line import/prefer-default-export
 export const supportedEntities = ['businessModelId', 'fleetId', 'demandSourceId'];
+
+export const CUSTOM_FIELDS_FILTER_SCOPE = 'filterByCustomFields';

package/src/utils/init.ts

@@ -0,0 +1,101 @@
+import { DataTypes } from 'sequelize';
+import { ModelCtor } from 'sequelize-typescript';
+import {
+  CustomFieldValue,
+} from '../models';
+import {
+  beforeFind,
+  enrichResults,
+  beforeBulkUpdate,
+  beforeUpdate,
+  beforeCreate,
+  beforeBulkCreate,
+} from '../hooks';
+import { customFieldsFilterScope } from '../scopes';
+import logger from './logger';
+import type { ModelFetcher, ModelOptions } from '../types';
+import { CUSTOM_FIELDS_FILTER_SCOPE } from './constants';
+
+export const addHooks = (models: ModelOptions[], getModel: ModelFetcher): void => {
+  models.forEach(async ({ name, scopeAttributes }) => {
+    try {
+      const model = getModel(name);
+      if (!model) {
+        logger.warn('sadot - tried to addHooks to a model that does not exist yet', {
+          name,
+          scopeAttributes,
+        });
+        return;
+      }
+      model.rawAttributes.customFields = {
+        type: DataTypes.VIRTUAL,
+      };
+      model.refreshAttributes();
+      // TODO: Uncomment after tests are passed
+      // model.addHook('afterFind', workaround);
+      model.addHook('beforeFind', 'sadot-beforeFind', beforeFind(scopeAttributes));
+      model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', beforeBulkCreate);
+      model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', beforeBulkUpdate);
+      model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes));
+      model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes));
+      model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes));
+      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes));
+      model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes));
+    } catch (e) {
+      logger.error(`Could not add custom fields hook to model ${name}. `, e);
+    }
+  });
+};
+
+export const removeHooks = (models: ModelOptions[], getModel: ModelFetcher): void => {
+  models.forEach(async ({ name }) => {
+    try {
+      const model = getModel(name);
+      if (!model) return;
+      if (model.rawAttributes.customFields) {
+        delete model.rawAttributes.customFields;
+        model.refreshAttributes();
+      }
+      // model.removeHook('afterFind', 'sadot-workaround');
+      model.removeHook('beforeFind', 'sadot-beforeFind');
+      model.removeHook('beforeBulkCreate', 'sadot-beforeBulkCreate');
+      model.removeHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate');
+      model.removeHook('beforeCreate', 'sadot-beforeCreate');
+      model.removeHook('beforeUpdate', 'sadot-beforeUpdate');
+      model.removeHook('afterFind', 'sadot-afterFind');
+      model.removeHook('afterUpdate', 'sadot-afterUpdate');
+    } catch (e) {
+      logger.error(`Could not add custom fields hook to model ${name}. `, e);
+    }
+  });
+};
+
+/**
+ *  Necessary associations for the {@link customFieldsFilterScope} scope
+ */
+const addAssociations = (model: ModelCtor, modelName: string): void => {
+  model.hasMany(CustomFieldValue, { foreignKey: 'modelId', as: 'customFieldValue' });
+  // TBC: maybe can be removed
+  CustomFieldValue.belongsTo(model, { foreignKey: 'modelId', as: modelName });
+};
+
+export const addScopes = (models: ModelOptions[], getModel: ModelFetcher): void => {
+  models.forEach(async ({ name, scopeAttributes }) => {
+    try {
+      const model = getModel(name);
+      if (!model) {
+        logger.warn('sadot - tried to addScopes to a model that does not exist yet', {
+          name,
+          scopeAttributes,
+        });
+        return;
+      }
+      // Necessary associations for the filtering scope
+      addAssociations(model, name);
+      // Add filter scope
+      model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, customFieldsFilterScope(name));
+    } catch (e) {
+      logger.error(`Could not add custom fields scopes to model ${name}. `, e);
+    }
+  });
+};

package/tsconfig.json

@@ -4,10 +4,13 @@
     "module": "commonjs",
     "declaration": true,
     "outDir": "./dist",
-    "strict": true,
     "esModuleInterop": true,
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "emitDecoratorMetadata": true,
+    "allowJs": true
   },
+  "include": [
+    "src/**/*",
+  ],
   "exclude": ["node_modules", "**/*.test.ts"]
 }