@autofleet/sadot 0.6.1-temp-2 → 0.6.1

package/dist/models/tests/AssociatedTestModel.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const sequelize_typescript_1 = require("sequelize-typescript");
+const TestModel_1 = __importDefault(require("./TestModel"));
+let AssociatedTestModel = class AssociatedTestModel extends sequelize_typescript_1.Model {
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        defaultValue: sequelize_typescript_1.DataType.UUIDV4,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "id", void 0);
+__decorate([
+    (0, sequelize_typescript_1.ForeignKey)(() => TestModel_1.default),
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "testModelId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "fleetId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: true,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "businessModelId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: true,
+    }),
+    __metadata("design:type", String)
+], AssociatedTestModel.prototype, "demandSourceId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BOOLEAN,
+    }),
+    __metadata("design:type", Boolean)
+], AssociatedTestModel.prototype, "anotherAttribute", void 0);
+__decorate([
+    (0, sequelize_typescript_1.BelongsTo)(() => TestModel_1.default),
+    __metadata("design:type", TestModel_1.default)
+], AssociatedTestModel.prototype, "testModel", void 0);
+AssociatedTestModel = __decorate([
+    (0, sequelize_typescript_1.Table)({ schema: 'custom-fields', createdAt: false, updatedAt: false })
+], AssociatedTestModel);
+exports.default = AssociatedTestModel;

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

@@ -0,0 +1,12 @@
+import { Model } from 'sequelize-typescript';
+import AssociatedTestModel from './AssociatedTestModel';
+declare class TestModel extends Model {
+    id: string;
+    fleetId: string;
+    businessModelId: string;
+    demandSourceId: string;
+    coolAttribute?: boolean;
+    associatedModels: AssociatedTestModel[];
+    customFields?: any;
+}
+export default TestModel;

package/dist/models/tests/TestModel.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const sequelize_typescript_1 = require("sequelize-typescript");
+const AssociatedTestModel_1 = __importDefault(require("./AssociatedTestModel"));
+let TestModel = class TestModel extends sequelize_typescript_1.Model {
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        defaultValue: sequelize_typescript_1.DataType.UUIDV4,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], TestModel.prototype, "id", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], TestModel.prototype, "fleetId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: true,
+    }),
+    __metadata("design:type", String)
+], TestModel.prototype, "businessModelId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: true,
+    }),
+    __metadata("design:type", String)
+], TestModel.prototype, "demandSourceId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BOOLEAN,
+    }),
+    __metadata("design:type", Boolean)
+], TestModel.prototype, "coolAttribute", void 0);
+__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);
+exports.default = TestModel;

package/dist/models/tests/contextAwareModels/ContextAwareTestModel.d.ts

@@ -0,0 +1,10 @@
+import { Model } from 'sequelize-typescript';
+import ContextTestModel from './ContextTestModel';
+declare class ContextAwareTestModel extends Model {
+    id: string;
+    contextId: string;
+    coolAttribute?: boolean;
+    customFields?: any;
+    context: ContextTestModel;
+}
+export default ContextAwareTestModel;

package/dist/models/tests/contextAwareModels/ContextAwareTestModel.js

@@ -0,0 +1,55 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const sequelize_typescript_1 = require("sequelize-typescript");
+const ContextTestModel_1 = __importDefault(require("./ContextTestModel"));
+let ContextAwareTestModel = class ContextAwareTestModel extends sequelize_typescript_1.Model {
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        defaultValue: sequelize_typescript_1.DataType.UUIDV4,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], ContextAwareTestModel.prototype, "id", void 0);
+__decorate([
+    (0, sequelize_typescript_1.ForeignKey)(() => ContextTestModel_1.default),
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+    }),
+    __metadata("design:type", String)
+], ContextAwareTestModel.prototype, "contextId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BOOLEAN,
+    }),
+    __metadata("design:type", Boolean)
+], ContextAwareTestModel.prototype, "coolAttribute", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.VIRTUAL,
+    }),
+    __metadata("design:type", Object)
+], ContextAwareTestModel.prototype, "customFields", void 0);
+__decorate([
+    (0, sequelize_typescript_1.BelongsTo)(() => ContextTestModel_1.default),
+    __metadata("design:type", ContextTestModel_1.default)
+], ContextAwareTestModel.prototype, "context", void 0);
+ContextAwareTestModel = __decorate([
+    (0, sequelize_typescript_1.Table)({ createdAt: false, updatedAt: false })
+], ContextAwareTestModel);
+exports.default = ContextAwareTestModel;

package/dist/models/tests/contextAwareModels/ContextTestModel.d.ts

@@ -0,0 +1,13 @@
+import { Model } from 'sequelize-typescript';
+declare enum EEntityTypes {
+    BUSINESS_MODEL = "businessModel",
+    CONTEXT = "context",
+    DEMAND_SOURCE = "demandSource",
+    FLEET = "fleet"
+}
+declare class ContextTestModel extends Model {
+    id: string;
+    entityId: string;
+    entityType: EEntityTypes;
+}
+export default ContextTestModel;

package/dist/models/tests/contextAwareModels/ContextTestModel.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const sequelize_typescript_1 = require("sequelize-typescript");
+// eslint-disable-next-line no-shadow
+var EEntityTypes;
+(function (EEntityTypes) {
+    EEntityTypes["BUSINESS_MODEL"] = "businessModel";
+    EEntityTypes["CONTEXT"] = "context";
+    EEntityTypes["DEMAND_SOURCE"] = "demandSource";
+    EEntityTypes["FLEET"] = "fleet";
+})(EEntityTypes || (EEntityTypes = {}));
+let ContextTestModel = class ContextTestModel extends sequelize_typescript_1.Model {
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.Column)({
+        defaultValue: sequelize_typescript_1.DataType.UUIDV4,
+        type: sequelize_typescript_1.DataType.UUID,
+    }),
+    __metadata("design:type", String)
+], ContextTestModel.prototype, "id", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+    }),
+    __metadata("design:type", String)
+], ContextTestModel.prototype, "entityId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.ENUM(...Object.values(EEntityTypes)),
+    }),
+    __metadata("design:type", String)
+], ContextTestModel.prototype, "entityType", void 0);
+ContextTestModel = __decorate([
+    (0, sequelize_typescript_1.Table)({ createdAt: false, updatedAt: false })
+], ContextTestModel);
+exports.default = ContextTestModel;

package/dist/repository/definition.d.ts

@@ -0,0 +1,20 @@
+import { FindOptions, WhereOptions } from 'sequelize';
+import { CustomFieldDefinition } from '../models';
+import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
+import { ModelOptions } from '../types';
+export declare const create: (data: CreateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
+export declare const findAll: (where: WhereOptions, options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findByIds: (ids: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findById: (id: string, options?: any) => Promise<CustomFieldDefinition | null>;
+export declare const findByEntityIds: (modelType: string, entityIds: string[], options?: FindOptions & {
+    modelOptions?: ModelOptions;
+}) => Promise<CustomFieldDefinition[]>;
+export declare const findByWhere: (where: any) => Promise<CustomFieldDefinition | null>;
+export declare const findDefinitionsByModels: (modelTypes: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const update: (id: string, data: UpdateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
+export declare const disable: (id: string) => Promise<any>;
+export declare const destroy: (id: string) => Promise<any>;
+/**
+ * Return the names of the required fields for a given model
+ */
+export declare const getRequiredFields: (modelType: string, modelId: string | string[], entityId: string | string[], modelOptions?: ModelOptions) => Promise<string[]>;

package/dist/repository/definition.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequiredFields = exports.destroy = exports.disable = exports.update = exports.findDefinitionsByModels = exports.findByWhere = exports.findByEntityIds = exports.findById = exports.findByIds = exports.findAll = exports.create = void 0;
+const sequelize_1 = require("sequelize");
+const models_1 = require("../models");
+const create = (data) => models_1.CustomFieldDefinition.create(data);
+exports.create = create;
+const findAll = (where, options = { withDisabled: false }) => {
+    const queryModel = options.withDisabled
+        ? models_1.CustomFieldDefinition.unscoped()
+        : models_1.CustomFieldDefinition;
+    return queryModel.scope('userScope').findAll({
+        where,
+        transaction: options.transaction,
+        raw: true,
+        include: options.include,
+    });
+};
+exports.findAll = findAll;
+const findByIds = (ids, options = { withDisabled: false }) => (0, exports.findAll)({ id: { [sequelize_1.Op.in]: ids } }, options);
+exports.findByIds = findByIds;
+const findById = (id, options = { withDisabled: false }) => {
+    const { withDisabled } = options;
+    if (withDisabled) {
+        return models_1.CustomFieldDefinition.unscoped().scope('userScope').findByPk(id);
+    }
+    return models_1.CustomFieldDefinition.scope('userScope').findByPk(id);
+};
+exports.findById = findById;
+const findByEntityIds = async (modelType, entityIds, options = {}) => {
+    const { include, useEntityIdFromInclude } = options.modelOptions;
+    const where = {
+        modelType,
+    };
+    if (!useEntityIdFromInclude) {
+        where.entityId = entityIds;
+    }
+    return models_1.CustomFieldDefinition.findAll({
+        where,
+        transaction: options.transaction,
+        include: include?.(entityIds),
+        raw: true,
+    });
+};
+exports.findByEntityIds = findByEntityIds;
+const findByWhere = (where) => models_1.CustomFieldDefinition.scope('userScope').findOne({
+    where,
+});
+exports.findByWhere = findByWhere;
+const findDefinitionsByModels = async (modelTypes, options) => {
+    const query = { modelType: { [sequelize_1.Op.in]: modelTypes } };
+    return models_1.CustomFieldDefinition.findAll({
+        where: query,
+        transaction: options?.transaction,
+    });
+};
+exports.findDefinitionsByModels = findDefinitionsByModels;
+const update = async (id, data) => {
+    const updatedDefinition = (await models_1.CustomFieldDefinition.scope('userScope').update(data, {
+        where: { id },
+        returning: true,
+        individualHooks: true,
+    }))[1][0];
+    return updatedDefinition;
+};
+exports.update = update;
+const disable = (id) => models_1.CustomFieldDefinition.update({ disabled: true }, { where: { id } });
+exports.disable = disable;
+const destroy = (id) => models_1.CustomFieldDefinition.destroy({ where: { id } });
+exports.destroy = destroy;
+/**
+ * Return the names of the required fields for a given model
+ */
+const getRequiredFields = async (modelType, modelId, entityId, modelOptions = {}) => {
+    const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+    const { include, useEntityIdFromInclude } = modelOptions;
+    const where = {
+        modelType,
+        required: true,
+    };
+    if (!useEntityIdFromInclude) {
+        where.entityId = entityIds;
+    }
+    const requiredFields = await models_1.CustomFieldDefinition.findAll({
+        where,
+        include: include?.(entityIds),
+        logging: true,
+    });
+    const requiredFieldsNames = requiredFields.map((definition) => definition.name);
+    return [...new Set(requiredFieldsNames)];
+};
+exports.getRequiredFields = getRequiredFields;

package/dist/repository/value.d.ts

@@ -0,0 +1,28 @@
+import type { FindOptions } from 'sequelize';
+import { CustomFieldValue } from '../models';
+import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+import { ModelOptions } from '../types';
+export declare const findByModelIdAndDefinition: (modelId: string, customFieldDefinitionId: string) => Promise<CustomFieldValue[]>;
+export declare const create: (data: CreateCustomFieldValue, withAssociations?: boolean) => Promise<CustomFieldValue>;
+export declare const findAllValues: () => Promise<CustomFieldValue[]>;
+/**
+ * Get all values for model instance id (with their definitions)
+ * @param modelId
+ * @returns CustomFieldValue[]
+ */
+export declare const findValuesByModelId: (modelId: string) => Promise<CustomFieldValue[]>;
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+export declare const findValuesByModelIds: (modelIds: string[], options?: any) => Promise<CustomFieldValue[]>;
+/**
+ * Try to update custom field values for a model instance.
+ * Create new value record if not exists, but fails if value's definition not exist.
+ * Return the updated values
+ */
+export declare const updateValues: (modelType: string, modelId: string, identifiers: string[], valuesToUpdate: ValuesToUpdate, options?: FindOptions & {
+    modelOptions?: ModelOptions;
+}) => Promise<CustomFieldValue[]>;
+export declare const deleteValue: (id: string, options?: any) => Promise<any>;

package/dist/repository/value.js

@@ -0,0 +1,117 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteValue = exports.updateValues = exports.findValuesByModelIds = exports.findValuesByModelId = exports.findAllValues = exports.create = exports.findByModelIdAndDefinition = void 0;
+const models_1 = require("../models");
+const DefinitionRepo = __importStar(require("./definition"));
+const logger_1 = __importDefault(require("../utils/logger"));
+const errors_1 = require("../errors");
+const findByModelIdAndDefinition = async (modelId, customFieldDefinitionId) => models_1.CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [models_1.CustomFieldDefinition] });
+exports.findByModelIdAndDefinition = findByModelIdAndDefinition;
+const create = async (data, withAssociations = false) => {
+    const created = await models_1.CustomFieldValue.create(data);
+    if (withAssociations) {
+        const createdWithAssociations = await (0, exports.findByModelIdAndDefinition)(created.modelId, created.customFieldDefinitionId);
+        return createdWithAssociations?.[0];
+    }
+    return created;
+};
+exports.create = create;
+const findAllValues = async () => models_1.CustomFieldValue.findAll({ include: [models_1.CustomFieldDefinition] });
+exports.findAllValues = findAllValues;
+/**
+ * Get all values for model instance id (with their definitions)
+ * @param modelId
+ * @returns CustomFieldValue[]
+ */
+const findValuesByModelId = async (modelId) => models_1.CustomFieldValue.findAll({ where: { modelId }, include: [models_1.CustomFieldDefinition] });
+exports.findValuesByModelId = findValuesByModelId;
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+const findValuesByModelIds = async (modelIds, options) => {
+    const { transaction } = options;
+    return models_1.CustomFieldValue.findAll({
+        where: { modelId: modelIds },
+        transaction,
+        raw: true,
+        nest: true,
+    });
+};
+exports.findValuesByModelIds = findValuesByModelIds;
+/**
+ * Try to update custom field values for a model instance.
+ * Create new value record if not exists, but fails if value's definition not exist.
+ * Return the updated values
+ */
+const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
+    const names = Object.keys(valuesToUpdate);
+    logger_1.default.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
+        names, options, valuesToUpdate, identifiers,
+    });
+    const { modelOptions, transaction } = options;
+    const where = {
+        modelType,
+        name: names,
+    };
+    if (!options.modelOptions?.useEntityIdFromInclude) {
+        where.entityId = identifiers;
+    }
+    const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) || [];
+    const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
+    if (fieldDefinitions.length !== names.length) {
+        logger_1.default.info(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
+        const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
+        throw new errors_1.MissingDefinitionError(missingDefinitions);
+    }
+    const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+    const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
+    if (valuesWithDisabledDefinitions?.length > 0) {
+        logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
+    }
+    const values = names.map((name) => ({
+        modelId,
+        value: valuesToUpdate[name],
+        updatedAt: new Date(),
+        customFieldDefinitionId: fieldDefinitions.find((def) => def.name === name).id,
+    }));
+    return Promise.all(values.map(async (value) => {
+        const [cfv] = await models_1.CustomFieldValue.upsert(value, {
+            transaction: options.transaction,
+        });
+        return cfv;
+    }));
+};
+exports.updateValues = updateValues;
+const deleteValue = (id, options = {}) => models_1.CustomFieldValue.update({ deletedAt: new Date() }, {
+    where: { id },
+    transaction: options.transaction,
+});
+exports.deleteValue = deleteValue;

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,55 @@
+"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 common_types_1 = require("@autofleet/common-types");
+const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
+/**
+ * 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) => {
+    if (!conditions || Object.keys(conditions).length === 0) {
+        return {};
+    }
+    // Build the WHERE clause for custom field filtering
+    const conditionsStrings = Object.entries(conditions)
+        .map(([key, value]) => {
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                // if empty array, the condition is ignored
+                return false;
+            }
+            const values = value.map((v) => `'${v}'`).join(',');
+            return `custom_fields->>'${key}' IN (${values})`;
+        }
+        return `custom_fields->>'${key}' = '${value}'`;
+    })
+        .filter(Boolean);
+    if (conditionsStrings.length === 0) {
+        return {};
+    }
+    const customFieldConditions = conditionsStrings.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 = 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/api/test-api.d.ts

@@ -0,0 +1,2 @@
+declare const app: import("express-serve-static-core").Express;
+export default app;