@autofleet/sadot 1.0.0-beta.0 → 1.0.0

package/dist/models/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initTestModels = exports.initTables = exports.ContextTestModel = exports.ContextAwareTestModel = exports.AssociatedTestModel = exports.TestModel = exports.CustomFieldDefinition = exports.CustomFieldValue = void 0;
+exports.initTestModels = exports.initTables = exports.ContextTestModel = exports.ContextAwareTestModel = exports.AssociatedTestModel = exports.TestModel = exports.CustomValidator = exports.CustomFieldEntries = exports.CustomFieldDefinition = exports.CustomFieldValue = void 0;
 /* eslint-disable no-param-reassign */
 const sequelize_1 = require("sequelize");
 const logger_1 = __importDefault(require("../utils/logger"));
@@ -19,33 +19,55 @@ const ContextTestModel_1 = __importDefault(require("./tests/contextAwareModels/C
 exports.ContextTestModel = ContextTestModel_1.default;
 const AssociatedTestModel_1 = __importDefault(require("./tests/AssociatedTestModel"));
 exports.AssociatedTestModel = AssociatedTestModel_1.default;
-const productionModels = [CustomFieldDefinition_1.default, CustomFieldValue_1.default];
+const CustomFieldEntries_1 = __importDefault(require("./CustomFieldEntries"));
+exports.CustomFieldEntries = CustomFieldEntries_1.default;
+const CustomValidator_1 = __importDefault(require("./CustomValidator"));
+exports.CustomValidator = CustomValidator_1.default;
+const productionModels = [CustomFieldDefinition_1.default, CustomFieldValue_1.default, CustomValidator_1.default];
 const testModels = [TestModel_1.default, AssociatedTestModel_1.default, ContextAwareTestModel_1.default, ContextTestModel_1.default];
 const SADOT_MIGRATION_PREFIX = 'sadot-migration';
-const SCHEMA_VERSION = 2;
-const CUSTOM_FIELDS_SCHEMA_VERSION = `${SADOT_MIGRATION_PREFIX}_${SCHEMA_VERSION}`;
-const initTables = async (sequelize, getUser) => {
+const SCHEMA_VERSION = '49c9dd1d-b1cc-445b-a911-fd349d783110';
+const initTables = async (sequelize, getUser, { schemaPrefix = SADOT_MIGRATION_PREFIX, schemaVersion = SCHEMA_VERSION, useCustomFieldsEntries = false, } = {}) => {
+    const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? '_withEntries' : ''}`;
     logger_1.default.info('custom-fields: initialize custom-fields tables');
     // Detect models and import them to the orm
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
     if (!sequelize.addModels) {
         throw new Error('sequelize instance must have addModels function');
     }
+    if (useCustomFieldsEntries) {
+        productionModels.push(CustomFieldEntries_1.default);
+    }
     sequelize.addModels(productionModels);
     CustomFieldDefinition_1.default.addScope('userScope', () => {
         const user = getUser();
-        if (user?.permissions) {
-            return {
-                where: {
-                    entityId: [
-                        ...Object.keys(user.permissions.fleets),
-                        ...Object.keys(user.permissions.businessModels),
-                        ...Object.keys(user.permissions.demandSources),
-                    ],
-                },
-            };
+        if (!user?.permissions) {
+            return {};
+        }
+        return {
+            where: {
+                entityId: [
+                    ...Object.keys(user.permissions.fleets),
+                    ...Object.keys(user.permissions.businessModels),
+                    ...Object.keys(user.permissions.demandSources),
+                ],
+            },
+        };
+    });
+    CustomValidator_1.default.addScope('userScope', () => {
+        const user = getUser();
+        if (!user?.permissions) {
+            return {};
         }
-        return {};
+        return {
+            where: {
+                entityId: [
+                    ...Object.keys(user.permissions.fleets),
+                    ...Object.keys(user.permissions.businessModels),
+                    ...Object.keys(user.permissions.demandSources),
+                ],
+            },
+        };
     });
     logger_1.default.info('custom-fields: models added');
     const SequelizeMeta = sequelize.define('SequelizeMeta', {
@@ -61,15 +83,31 @@ const initTables = async (sequelize, getUser) => {
         timestamps: false,
         schema: 'public',
     });
-    const migrations = await SequelizeMeta.findAll({ raw: true });
-    const currentSadotSchemaVersion = migrations
-        .reverse().find((m) => m.name.includes(SADOT_MIGRATION_PREFIX));
-    if (!currentSadotSchemaVersion
-        || currentSadotSchemaVersion.name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
+    logger_1.default.info('custom-fields: starting migrations');
+    const migrations = await SequelizeMeta.findAll({ where: { name: { [sequelize_1.Op.like]: `${schemaPrefix}%` } }, raw: true });
+    const currentSadotSchemaVersion = migrations.at(-1);
+    const expectedSchemaVersionIndex = migrations.findIndex((m) => m.name === CUSTOM_FIELDS_SCHEMA_VERSION);
+    logger_1.default.info('custom-fields: migrations', { migrations, currentSadotSchemaVersion, expectedSchemaVersionIndex });
+    if (!currentSadotSchemaVersion || currentSadotSchemaVersion.name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
+        logger_1.default.info('custom-fields: syncing models');
         await CustomFieldDefinition_1.default.sync({ alter: true });
         await CustomFieldValue_1.default.sync({ alter: true });
-        await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
+        // T.Y TODO: Remove the if statement once we're ready to add the new entries table for all MS
+        if (useCustomFieldsEntries) {
+            await CustomFieldEntries_1.default.sync({ alter: true });
+        }
+        // Always sync CustomValidator
+        await CustomValidator_1.default.sync({ alter: true });
+        if (expectedSchemaVersionIndex === -1) {
+            await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
+        }
         logger_1.default.info('custom-fields: models synced');
+        if (migrations.length && expectedSchemaVersionIndex !== -1 && expectedSchemaVersionIndex < migrations.length - 1) {
+            // We have existing migrations, and we are calling `sync`.
+            // This means we are in a `down` migration, and hence we should delete newer migrations to ensure we can reapply them.
+            const migrationsToDelete = migrations.slice(expectedSchemaVersionIndex + 1);
+            await SequelizeMeta.destroy({ where: { name: { [sequelize_1.Op.in]: migrationsToDelete.map((m) => m.name) } } });
+        }
     }
 };
 exports.initTables = initTables;

package/dist/repository/definition.d.ts

@@ -1,20 +1,36 @@
-import { type FindOptions, type WhereOptions } from 'sequelize';
-import { CustomFieldDefinition } from '../models';
+import { type Includeable, type Transaction, type FindOptions, type WhereOptions } from 'sequelize';
+import { CustomFieldDefinition, type CustomFieldEntries } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
 import type { 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>;
+interface SadotFindOptions {
+    withDisabled?: boolean;
+    transaction?: Transaction;
+    include?: Includeable | Includeable[];
+}
+type SadotGetDefinitionsByEntityIdsOptions = FindOptions & {
+    modelOptions?: ModelOptions;
+} & Pick<SadotFindOptions, 'withDisabled'>;
+export declare const findAll: (where: WhereOptions, options?: SadotFindOptions) => Promise<CustomFieldDefinition[]>;
+export declare const findByIds: (ids: string[], options?: SadotFindOptions) => Promise<CustomFieldDefinition[]>;
+export declare const findById: (id: string, options?: Pick<SadotFindOptions, 'withDisabled'>) => 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>;
+export declare const disable: (id: string) => Promise<[affectedCount: number]>;
+export declare const destroy: (id: string) => Promise<number>;
 /**
  * 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[]>;
+/**
+ * @returns A promise resolving with a dictionary of custom field definitions by name.
+ * @throws A {@link MissingDefinitionError} if any of the custom fields doesn't have a definition.
+ */
+export declare const getCustomFieldDefinitionsDictionary: (instances: CustomFieldEntries[], options?: SadotGetDefinitionsByEntityIdsOptions) => Promise<{
+    [definitionName: string]: CustomFieldDefinition;
+}>;
+export {};

package/dist/repository/definition.js

@@ -1,8 +1,9 @@
 "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;
+exports.getCustomFieldDefinitionsDictionary = 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 errors_1 = require("../errors");
 const create = (data) => models_1.CustomFieldDefinition.create(data);
 exports.create = create;
 const findAll = (where, options = { withDisabled: false }) => {
@@ -31,10 +32,8 @@ const findByEntityIds = async (modelType, entityIds, options = {}) => {
     const { include, useEntityIdFromInclude } = options.modelOptions;
     const where = {
         modelType,
+        ...(!useEntityIdFromInclude && { entityId: { [sequelize_1.Op.in]: entityIds } }),
     };
-    if (!useEntityIdFromInclude) {
-        where.entityId = entityIds;
-    }
     return models_1.CustomFieldDefinition.findAll({
         where,
         transaction: options.transaction,
@@ -77,10 +76,8 @@ const getRequiredFields = async (modelType, modelId, entityId, modelOptions = {}
     const where = {
         modelType,
         required: true,
+        ...(!useEntityIdFromInclude && { entityId: { [sequelize_1.Op.in]: entityIds } }),
     };
-    if (!useEntityIdFromInclude) {
-        where.entityId = entityIds;
-    }
     const requiredFields = await models_1.CustomFieldDefinition.findAll({
         where,
         include: include?.(entityIds),
@@ -90,3 +87,35 @@ const getRequiredFields = async (modelType, modelId, entityId, modelOptions = {}
     return [...new Set(requiredFieldsNames)];
 };
 exports.getRequiredFields = getRequiredFields;
+/**
+ * @returns A promise resolving with a dictionary of custom field definitions by name.
+ * @throws A {@link MissingDefinitionError} if any of the custom fields doesn't have a definition.
+ */
+const getCustomFieldDefinitionsDictionary = async (instances, options = { withDisabled: false, modelOptions: {} }) => {
+    const { modelType } = instances[0]?.dataValues ?? {};
+    const customFields = new Set();
+    const modelIds = [];
+    const entityIds = new Set();
+    instances.forEach((instance) => {
+        const { dataValues: { modelId, entityId, customFields: instanceCustomFields } } = instance;
+        modelIds.push(modelId);
+        entityIds.add(entityId);
+        Object.keys(instanceCustomFields ?? {}).forEach((fieldName) => {
+            customFields.add(fieldName);
+        });
+    });
+    const where = {
+        modelType,
+        entityId: { [sequelize_1.Op.in]: Array.from(entityIds) },
+        name: { [sequelize_1.Op.in]: Array.from(customFields) },
+    };
+    const definitions = await (0, exports.findAll)(where, { ...options });
+    const matchedDefinitions = definitions.filter((def) => customFields.has(def.name));
+    const matchedDefinitionsByName = Object.fromEntries(matchedDefinitions.map((definition) => [definition.name, definition]));
+    if (!definitions?.length || matchedDefinitions.length !== customFields.size) {
+        const unmatchedCustomFields = Array.from(customFields).filter((customField) => !matchedDefinitionsByName[customField]);
+        throw new errors_1.MissingDefinitionError(unmatchedCustomFields);
+    }
+    return matchedDefinitionsByName;
+};
+exports.getCustomFieldDefinitionsDictionary = getCustomFieldDefinitionsDictionary;

package/dist/repository/entries.d.ts

@@ -0,0 +1,13 @@
+import type { FindOptions, Includeable, Transaction } from 'sequelize';
+import { CustomFieldEntries } from '../models';
+import type { ModelOptions } from '../types';
+type CustomFieldEntriesModelOptions = ModelOptions & {
+    include?: Includeable;
+    transaction?: Transaction;
+};
+export declare const findEntriesByModelId: (modelId: string, options?: CustomFieldEntriesModelOptions) => Promise<CustomFieldEntries>;
+export declare const findEntriesByModelIds: (modelIds: string[], options?: CustomFieldEntriesModelOptions) => Promise<CustomFieldEntries[]>;
+export declare const updateEntries: (modelId: string, modelType: string, customFields: Record<string, any>, identifiers: string[], options?: FindOptions & {
+    modelOptions?: ModelOptions;
+}) => Promise<[CustomFieldEntries, boolean]>;
+export {};

package/dist/repository/entries.js

@@ -0,0 +1,92 @@
+"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.updateEntries = exports.findEntriesByModelIds = exports.findEntriesByModelId = void 0;
+const models_1 = require("../models");
+const logger_1 = __importDefault(require("../utils/logger"));
+const errors_1 = require("../errors");
+const DefinitionRepo = __importStar(require("./definition"));
+const formatValues_1 = require("./utils/formatValues");
+const findEntriesByModelId = async (modelId, options = {}) => {
+    const { transaction } = options;
+    return models_1.CustomFieldEntries.findOne({
+        where: { modelId },
+        transaction,
+    });
+};
+exports.findEntriesByModelId = findEntriesByModelId;
+const findEntriesByModelIds = async (modelIds, options = {}) => {
+    const { transaction } = options;
+    return models_1.CustomFieldEntries.findAll({
+        where: { modelId: modelIds },
+        transaction,
+    });
+};
+exports.findEntriesByModelIds = findEntriesByModelIds;
+const updateEntries = async (modelId, modelType, customFields, identifiers, options = {}) => {
+    const customFieldsNames = Object.keys(customFields);
+    logger_1.default.debug(`custom-fields: updating entries for ${modelType} ${modelId}`, {
+        customFieldsNames,
+        optionsKeys: options ? Object.keys(options) : null,
+        customFields,
+        identifiers,
+    });
+    const { modelOptions, transaction } = options;
+    const where = {
+        modelType,
+        name: customFieldsNames,
+        ...(!options.modelOptions?.useEntityIdFromInclude && { 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 !== customFieldsNames.length) {
+        logger_1.default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names: customFieldsNames, fieldDefinitions });
+        const missingDefinitions = customFieldsNames.filter((name) => !fieldDefinitions.some((def) => def.name === name));
+        throw new errors_1.MissingDefinitionError(missingDefinitions);
+    }
+    const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+    const valuesWithDisabledDefinitions = customFieldsNames.filter((name) => disabledNames.includes(name));
+    if (valuesWithDisabledDefinitions?.length > 0) {
+        logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
+    }
+    const definitionsByName = Object.fromEntries(fieldDefinitions.map((definition) => [definition.name, definition]));
+    // If we need to format the value before we save it
+    Object.entries(customFields)
+        .filter(([definitionName]) => formatValues_1.formatFunctions[definitionsByName[definitionName].fieldType])
+        .forEach(([definitionName, value]) => {
+        const { fieldType } = definitionsByName[definitionName];
+        customFields[definitionName] = formatValues_1.formatFunctions[fieldType](value);
+    });
+    return models_1.CustomFieldEntries.upsert({
+        modelId,
+        entityId: fieldDefinitions[0].entityId,
+        modelType,
+        customFields,
+    }, options);
+};
+exports.updateEntries = updateEntries;

package/dist/repository/utils/formatValues.d.ts

@@ -0,0 +1,3 @@
+export declare const formatFunctions: {
+    date: (value: any) => string;
+};

package/dist/repository/utils/formatValues.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFunctions = void 0;
+const constants_1 = require("../../utils/constants");
+exports.formatFunctions = {
+    [constants_1.CustomFieldDefinitionType.DATE]: (value) => {
+        if (value) {
+            const date = new Date(value);
+            if (date.toString() === 'Invalid Date') {
+                throw new Error(`Invalid date value: ${value}`);
+            }
+            return date.toISOString();
+        }
+        return null;
+    },
+};

package/dist/repository/validator.d.ts

@@ -0,0 +1,21 @@
+import type { IncludeOptions, Transactionable } from 'sequelize';
+import { CustomValidator } from '../models';
+export interface FindValidatorOptions extends Transactionable {
+    withDisabled?: boolean;
+    attributes?: string[];
+    raw?: boolean;
+    include?: IncludeOptions[];
+}
+export interface ValidatorAttributes {
+    entityId: string;
+    entityType: string;
+    modelType: string;
+    schema: CustomValidator['schema'];
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export declare const create: (validatorAttributes: ValidatorAttributes, options?: Transactionable) => Promise<CustomValidator>;
+export declare const findAll: (where?: {}, options?: FindValidatorOptions) => Promise<CustomValidator[]>;
+export declare const findAllByModelType: (modelType: string, entityId: string, options?: FindValidatorOptions) => Promise<CustomValidator[]>;
+export declare const update: (id: string, updates: Partial<ValidatorAttributes>, options?: Transactionable) => Promise<[number, CustomValidator[]]>;
+export declare const disable: (id: string, options?: Transactionable) => Promise<[number, CustomValidator[]]>;

package/dist/repository/validator.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disable = exports.update = exports.findAllByModelType = exports.findAll = exports.create = void 0;
+const logger_1 = __importDefault(require("../utils/logger"));
+const models_1 = require("../models");
+const create = async (validatorAttributes, options = {}) => {
+    logger_1.default.debug('custom-validator - create validator');
+    // Use unknown type to bypass TypeScript errors while maintaining compatibility
+    const validator = await models_1.CustomValidator.create(validatorAttributes, options);
+    return validator;
+};
+exports.create = create;
+const findAll = async (where = {}, options = { withDisabled: false }) => {
+    logger_1.default.debug('custom-validator - find all validators');
+    const { transaction, withDisabled } = options;
+    let validators;
+    if (withDisabled) {
+        // If withDisabled is true, use unscoped to ignore the default scope that filters disabled items
+        // Apply the userScope separately to maintain permission filtering
+        validators = await models_1.CustomValidator.unscoped().scope('userScope').findAll({
+            where,
+            transaction,
+        });
+    }
+    else {
+        // Use defaultScope and userScope to filter both disabled and by permissions
+        // The defaultScope keeps only non-disabled validators
+        validators = await models_1.CustomValidator.scope(['defaultScope', 'userScope']).findAll({
+            where,
+            transaction,
+        });
+    }
+    return validators;
+};
+exports.findAll = findAll;
+const findAllByModelType = async (modelType, entityId, options = { withDisabled: false }) => {
+    logger_1.default.debug('custom-validator - find all validators by model type');
+    return (0, exports.findAll)({
+        modelType,
+        ...(!options.include && {
+            entityId,
+        }),
+    }, options);
+};
+exports.findAllByModelType = findAllByModelType;
+const update = async (id, updates, options) => {
+    logger_1.default.debug('custom-validator - update validator');
+    return models_1.CustomValidator.update(updates, {
+        where: { id },
+        returning: true,
+        ...options,
+    });
+};
+exports.update = update;
+const disable = async (id, options) => {
+    logger_1.default.debug('custom-validator - disable validator');
+    return (0, exports.update)(id, { disabled: true }, options);
+};
+exports.disable = disable;

package/dist/repository/value.d.ts

@@ -24,5 +24,5 @@ export declare const findValuesByModelIds: (modelIds: string[], options?: any) =
  */
 export declare const updateValues: (modelType: string, modelId: string, identifiers: string[], valuesToUpdate: ValuesToUpdate, options?: FindOptions & {
     modelOptions?: ModelOptions;
-}, defineAllDefaults?: boolean) => Promise<CustomFieldValue[]>;
+}) => Promise<CustomFieldValue[]>;
 export declare const deleteValue: (id: string, options?: any) => Promise<any>;

package/dist/repository/value.js

@@ -31,7 +31,7 @@ const models_1 = require("../models");
 const DefinitionRepo = __importStar(require("./definition"));
 const logger_1 = __importDefault(require("../utils/logger"));
 const errors_1 = require("../errors");
-const constants_1 = require("../utils/constants");
+const formatValues_1 = require("./utils/formatValues");
 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) => {
@@ -67,24 +67,12 @@ const findValuesByModelIds = async (modelIds, options) => {
     });
 };
 exports.findValuesByModelIds = findValuesByModelIds;
-const formatFunctions = {
-    [constants_1.CustomFieldDefinitionType.DATE]: (value) => {
-        if (value) {
-            const date = new Date(value);
-            if (date.toString() === 'Invalid Date') {
-                throw new Error(`Invalid date value: ${value}`);
-            }
-            return date.toISOString();
-        }
-        return null;
-    },
-};
 /**
  * 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 = {}, defineAllDefaults = false) => {
+const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
     const names = Object.keys(valuesToUpdate);
     logger_1.default.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
         names,
@@ -96,11 +84,9 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     const where = {
         modelType,
         name: names,
+        ...(!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }),
     };
-    if (!options.modelOptions?.useEntityIdFromInclude) {
-        where.entityId = identifiers;
-    }
-    const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(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.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
@@ -112,28 +98,17 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     if (valuesWithDisabledDefinitions?.length > 0) {
         logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
     }
-    const visitedFields = new Set();
     const values = names.map((name) => {
         const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
-        visitedFields.add(fieldDefinition);
-        const formatFunction = formatFunctions[fieldDefinition.fieldType];
+        const formatFunction = formatValues_1.formatFunctions[fieldDefinition.fieldType];
+        const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
         return {
             modelId,
-            value: (formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name]) ?? fieldDefinition.defaultValue,
             updatedAt: new Date(),
             customFieldDefinitionId: fieldDefinition.id,
+            value: value !== undefined ? value : fieldDefinition.defaultValue,
         };
     });
-    if (defineAllDefaults) {
-        fieldDefinitions.filter((def) => !visitedFields.has(def) && ![null, undefined].includes(def.defaultValue)).forEach(({ id, defaultValue }) => {
-            values.push({
-                modelId,
-                value: defaultValue,
-                updatedAt: new Date(),
-                customFieldDefinitionId: id,
-            });
-        });
-    }
     return Promise.all(values.map(async (value) => {
         const [cfv] = await models_1.CustomFieldValue.upsert(value, {
             transaction: options.transaction,

package/dist/scopes/filter.d.ts

@@ -1,22 +1,5 @@
-import { type WhereOptions } from 'sequelize';
-/**
- * Type representing possible condition values.
- * Currently supporting strings and arrays of strings.
- * More types to be added (TBA).
- */
-type ConditionWithOperator = {
-    operator: string;
-    value: string;
-};
-export type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
-export type CustomFieldSort = {
-    field: string;
-    direction: 'ASC' | 'DESC';
-};
-export type CustomFieldFilterOptions = {
-    where?: WhereOptions;
-    replacements?: Record<string, string>;
-};
+import type { CustomFieldOptions } from '../types';
+import { type ConditionValue, type CustomFieldFilterOptions } from './helpers/filter.helpers';
 type customFieldsFilterScopeParams = {
     replacementsMap: Record<string, string>;
     scopeValue: Record<string, ConditionValue>;
@@ -28,9 +11,9 @@ type customFieldsFilterScopeParams = {
  * @param name - The model type name used to join custom_field_definitions.
  * @returns A function that takes conditions and returns the Sequelize options object.
  */
-export declare const customFieldsFilterScope: (name: string) => ({ replacementsMap: replacements, scopeValue: conditions, }: customFieldsFilterScopeParams) => CustomFieldFilterOptions;
-export declare const scopeName = "filterByCustomFields";
-export declare const customFieldsSortScope: (name: string) => ({ replacementsMap, scopeValue: sort }: {
+export declare const customFieldsFilterScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap: replacements, scopeValue: conditions }: customFieldsFilterScopeParams) => CustomFieldFilterOptions;
+export declare const scopeName: "filterByCustomFields";
+export declare const customFieldsSortScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap, scopeValue: sort }: {
     replacementsMap: any;
     scopeValue: any;
 }) => {