@autofleet/sadot 1.1.3 → 1.1.5-beta

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

@@ -1,2 +1,53 @@
-import{__decorateMetadata as e}from"../../../_virtual/_@oxc-project_runtime@0.101.0/helpers/decorateMetadata.js";import{__decorate as t}from"../../../_virtual/_@oxc-project_runtime@0.101.0/helpers/decorate.js";import n from"./ContextTestModel.js";import{BelongsTo as r,Column as i,DataType as a,ForeignKey as o,Model as s,PrimaryKey as c,Table as l}from"sequelize-typescript";var u;let d=class extends s{};t([c,i({type:a.UUID,defaultValue:a.UUIDV4,allowNull:!1}),e(`design:type`,String)],d.prototype,`id`,void 0),t([o(()=>n),i({type:a.UUID}),e(`design:type`,String)],d.prototype,`contextId`,void 0),t([i({type:a.BOOLEAN}),e(`design:type`,Boolean)],d.prototype,`coolAttribute`,void 0),t([i({type:a.VIRTUAL}),e(`design:type`,Object)],d.prototype,`customFields`,void 0),t([r(()=>n),e(`design:type`,typeof(u=n!==void 0&&n)==`function`?u:Object)],d.prototype,`context`,void 0),d=t([l({createdAt:!1,updatedAt:!1,modelName:`ContextAwareTestModel`})],d);var f=d;export{f as default};
-//# sourceMappingURL=ContextAwareTestModel.js.map
+"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

@@ -1,2 +1,47 @@
-import{__decorateMetadata as e}from"../../../_virtual/_@oxc-project_runtime@0.101.0/helpers/decorateMetadata.js";import{__decorate as t}from"../../../_virtual/_@oxc-project_runtime@0.101.0/helpers/decorate.js";import{Column as n,DataType as r,Model as i,PrimaryKey as a,Table as o}from"sequelize-typescript";var s=function(e){return e.BUSINESS_MODEL=`businessModel`,e.CONTEXT=`context`,e.DEMAND_SOURCE=`demandSource`,e.FLEET=`fleet`,e}(s||{});let c=class extends i{};t([a,n({defaultValue:r.UUIDV4,type:r.UUID}),e(`design:type`,String)],c.prototype,`id`,void 0),t([n({type:r.UUID}),e(`design:type`,String)],c.prototype,`entityId`,void 0),t([n({type:r.ENUM(...Object.values(s))}),e(`design:type`,String)],c.prototype,`entityType`,void 0),c=t([o({createdAt:!1,updatedAt:!1,modelName:`ContextTestModel`})],c);var l=c;export{l as default};
-//# sourceMappingURL=ContextTestModel.js.map
+"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,36 @@
+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>;
+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<[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,2 +1,121 @@
-import{MissingDefinitionError as e}from"../errors/index.js";import t from"../models/CustomFieldDefinition.js";import"../models/index.js";import{Op as n}from"sequelize";const r=e=>t.create(e),i=(e,n={withDisabled:!1})=>(n.withDisabled?t.unscoped():t).scope(`userScope`).findAll({where:e,transaction:n.transaction,raw:!0,include:n.include}),a=(e,t={withDisabled:!1})=>i({id:{[n.in]:e}},t),o=(e,n={withDisabled:!1})=>{let{withDisabled:r}=n;return r?t.unscoped().scope(`userScope`).findByPk(e):t.scope(`userScope`).findByPk(e)},s=async(e,r,i={})=>{let{include:a,useEntityIdFromInclude:o}=i.modelOptions,s={modelType:e,...!o&&{entityId:{[n.in]:r}}};return t.findAll({where:s,transaction:i.transaction,include:a?.(r),raw:!0})},c=e=>t.scope(`userScope`).findOne({where:e}),l=async(e,n)=>(await t.scope(`userScope`).update(n,{where:{id:e},returning:!0,individualHooks:!0}))[1][0],u=async(t,{findAll:r,modelOptions:a={},withDisabled:o=!1,...s}={withDisabled:!1,modelOptions:{}})=>{let{modelType:c}=t[0]?.dataValues??{},l=new Set,u=[],d=new Set;t.forEach(e=>{let{dataValues:{modelId:t,entityId:n,customFields:r}}=e;u.push(t),d.add(n),Object.keys(r??{}).forEach(e=>{l.add(e)})});let f={modelType:c,entityId:{[n.in]:Array.from(d)},name:{[n.in]:Array.from(l)}},p=await(r??i)(f,{withDisabled:o,modelOptions:a,...s}),m=p.filter(e=>l.has(e.name)),h=Object.fromEntries(m.map(e=>[e.name,e]));if(!p?.length||m.length!==l.size)throw new e(Array.from(l).filter(e=>!h[e]));return h};export{r as create,i as findAll,s as findByEntityIds,o as findById,a as findByIds,c as findByWhere,u as getCustomFieldDefinitionsDictionary,l as update};
-//# sourceMappingURL=definition.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 }) => {
+    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,
+        ...(!useEntityIdFromInclude && { entityId: { [sequelize_1.Op.in]: 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,
+        ...(!useEntityIdFromInclude && { entityId: { [sequelize_1.Op.in]: 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;
+/**
+ * @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

@@ -1,2 +1,92 @@
-import e from"../utils/logger/index.js";import{MissingDefinitionError as t}from"../errors/index.js";import{findAll as n}from"./definition.js";import r from"../models/CustomFieldEntries.js";import"../models/index.js";import{formatFunctions as i}from"./utils/formatValues.js";const a=async(e,t={})=>{let{transaction:n}=t;return r.findOne({where:{modelId:e},transaction:n})},o=async(e,t={})=>{let{transaction:n}=t;return r.findAll({where:{modelId:e},transaction:n})},s=async(a,o,s,c,l={})=>{let u=Object.keys(s);e.debug(`custom-fields: updating entries for ${o} ${a}`,{customFieldsNames:u,optionsKeys:l?Object.keys(l):null,customFields:s,identifiers:c});let{modelOptions:d,transaction:f}=l,p=await n({modelType:o,name:u,...!l.modelOptions?.useEntityIdFromInclude&&{entityId:c}},{withDisabled:!0,transaction:f,include:d.include?.(c)})??[],m=p.filter(e=>e.disabled);if(p.length!==u.length)throw e.warn(`custom-fields: missing definitions for ${o} ${a}`,{names:u,fieldDefinitions:p}),new t(u.filter(e=>!p.some(t=>t.name===e)));let h=m?.map(e=>e.name)||[],g=u.filter(e=>h.includes(e));g?.length>0&&e.warn(`custom-fields: trying to update disabled values: ${g.join(`, `)}`);let _=Object.fromEntries(p.map(e=>[e.name,e]));return Object.entries(s).filter(([e])=>i[_[e].fieldType]).forEach(([e,t])=>{let{fieldType:n}=_[e];s[e]=i[n](t)}),r.upsert({modelId:a,entityId:p[0].entityId,modelType:o,customFields:s},l)};export{a as findEntriesByModelId,o as findEntriesByModelIds,s as updateEntries};
-//# sourceMappingURL=entries.js.map
+"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

@@ -1,2 +1,16 @@
-import{CustomFieldDefinitionType as e}from"../../utils/constants/index.js";const t={[e.DATE]:e=>{if(e){let t=new Date(e);if(t.toString()===`Invalid Date`)throw Error(`Invalid date value: ${e}`);return t.toISOString()}return null}};export{t as formatFunctions};
-//# sourceMappingURL=formatValues.js.map
+"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,27 @@
+import type { FindOptions, IncludeOptions, Transactionable } from 'sequelize';
+import { CustomValidator } from '../models';
+import type { ModelOptions } from '../types';
+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?: FindOptions & {
+    modelOptions?: ModelOptions;
+    withDisabled?: boolean;
+}) => Promise<CustomValidator[]>;
+export declare const findAllByModelType: (modelType: string, entityId: string, options?: FindOptions & {
+    modelOptions?: ModelOptions;
+}) => 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

@@ -1,2 +1,69 @@
-import e from"../utils/logger/index.js";import t from"../models/CustomValidator.js";import"../models/index.js";const n=async(n,r={})=>(e.debug(`custom-validator - create validator`),await t.create(n,r)),r=async(n={},r={})=>{e.debug(`custom-validator - find all validators`);let{transaction:i,withDisabled:a,include:o,attributes:s,raw:c}=r,l;return l=a?await t.unscoped().scope(`userScope`).findAll({where:n,transaction:i,include:o,attributes:s,raw:c}):await t.scope([`defaultScope`,`userScope`]).findAll({where:n,transaction:i,include:o,attributes:s,raw:c}),l},i=async(t,n,i={})=>(e.debug(`custom-validator - find all validators by model type`),r({modelType:t,...!i?.modelOptions?.useEntityIdFromInclude&&{entityId:n}},{...i,include:i?.modelOptions?.include?.(n)})),a=async(n,r,i)=>(e.debug(`custom-validator - update validator`),t.update(r,{where:{id:n},returning:!0,...i})),o=async(t,n)=>(e.debug(`custom-validator - disable validator`),a(t,{disabled:!0},n));export{n as create,o as disable,r as findAll,i as findAllByModelType,a as update};
-//# sourceMappingURL=validator.js.map
+"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 = {}) => {
+    logger_1.default.debug('custom-validator - find all validators');
+    const { transaction, withDisabled, include, attributes, raw, } = 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,
+            include,
+            attributes,
+            raw,
+        });
+    }
+    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,
+            include,
+            attributes,
+            raw,
+        });
+    }
+    return validators;
+};
+exports.findAll = findAll;
+const findAllByModelType = async (modelType, entityId, options = {}) => {
+    logger_1.default.debug('custom-validator - find all validators by model type');
+    return (0, exports.findAll)({
+        modelType,
+        ...(!options?.modelOptions?.useEntityIdFromInclude && { entityId }),
+    }, {
+        ...options,
+        include: options?.modelOptions?.include?.(entityId),
+    });
+};
+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

@@ -0,0 +1,28 @@
+import type { FindOptions } from 'sequelize';
+import { CustomFieldValue } from '../models';
+import type { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+import type { 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>;