@autofleet/sadot 1.1.3 → 1.1.5-beta

package/dist/utils/db/index.js

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

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

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

package/dist/utils/helpers/index.js

@@ -1,2 +1,40 @@
-import{CustomFieldDefinitionType as e}from"../constants/index.js";import{Op as t}from"sequelize";import{Sequelize as n}from"sequelize-typescript";import{randomInt as r}from"node:crypto";const i=(e=5)=>Array.from({length:e},()=>`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`.charAt(r(52))).join(``),a=(r,i,a,o=[e.DATETIME,e.DATE])=>{let s=o.map(e=>`'${e}'`).join(`,`),c=`EXISTS ( SELECT 1 FROM "custom_field_values" AS "cv" INNER JOIN custom_field_definitions AS cd  ON cd.entity_id = '${a}' AND cv.custom_field_definition_id = cd.id AND cd.model_type = '${i.name}' ${s?`AND cd.field_type NOT IN (${s})`:``} WHERE "cv"."deleted_at" IS NULL AND "cv"."model_id" = "${i.name}"."id" AND CAST("cv"."value" AS TEXT) ILIKE :searchTerm)`;return{where:{[t.or]:[n.where(n.literal(c),!0)]},replacements:{searchTerm:`%${r}%`}}};export{a as generateCustomFieldSearchQueryPayload,i as generateRandomString};
-//# sourceMappingURL=index.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCustomFieldSearchQueryPayload = exports.generateRandomString = void 0;
+/* eslint-disable import/prefer-default-export */
+const sequelize_1 = require("sequelize");
+const sequelize_typescript_1 = require("sequelize-typescript");
+const node_crypto_1 = require("node:crypto");
+const constants_1 = require("../constants");
+const generateRandomString = (length = 5) => {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    return Array.from({ length }, () => characters.charAt((0, node_crypto_1.randomInt)(characters.length))).join('');
+};
+exports.generateRandomString = generateRandomString;
+const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
+    constants_1.CustomFieldDefinitionType.DATETIME,
+    constants_1.CustomFieldDefinitionType.DATE,
+]) => {
+    const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(',');
+    const subQuery = 'EXISTS ('
+        + ' SELECT 1'
+        + ' FROM "custom_field_values" AS "cv"'
+        + ' INNER JOIN custom_field_definitions AS cd '
+        + ` ON cd.entity_id = '${entityId}'`
+        + ' AND cv.custom_field_definition_id = cd.id'
+        + ` AND cd.model_type = '${model.name}'`
+        + ` ${excludedTypesString ? `AND cd.field_type NOT IN (${excludedTypesString})` : ''}`
+        + ' WHERE'
+        + ' "cv"."deleted_at" IS NULL'
+        + ` AND "cv"."model_id" = "${model.name}"."id"`
+        + ' AND CAST("cv"."value" AS TEXT) ILIKE :searchTerm)';
+    return {
+        where: {
+            [sequelize_1.Op.or]: [
+                sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.literal(subQuery), true),
+            ],
+        },
+        replacements: { searchTerm: `%${searchTerm}%` },
+    };
+};
+exports.generateCustomFieldSearchQueryPayload = generateCustomFieldSearchQueryPayload;

package/dist/utils/init.d.ts

@@ -0,0 +1,7 @@
+import type { CustomFieldOptions, ModelFetcher, Models } from '../types';
+export declare const addHooks: (models: Models[], getModel: ModelFetcher, sadotOptions?: {
+    useCustomFieldsEntries: boolean;
+}) => void;
+export declare const removeHooks: (models: Models[], getModel: ModelFetcher) => void;
+export declare const addScopes: (models: Models[], getModel: ModelFetcher, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => void;
+export declare const applyCustomAssociation: (models: Models[]) => void;

package/dist/utils/init.js

@@ -1,2 +1,112 @@
-import e from"./logger/index.js";import t from"../models/CustomFieldDefinition.js";import n from"../models/CustomFieldValue.js";import r from"../models/CustomValidator.js";import"../models/index.js";import i from"../hooks/enrich.js";import{beforeFind as a}from"../hooks/find.js";import{beforeBulkCreate as o,beforeBulkUpdate as s,beforeCreate as c,beforeUpdate as l}from"../hooks/hooks.js";import"../hooks/index.js";import{customFieldsFilterScope as u,customFieldsSortScope as d}from"../scopes/filter.js";import"../scopes/index.js";import{DataTypes as f}from"sequelize";import{customFields as p}from"@autofleet/common-types";import{CUSTOM_FIELDS_SORT_SCOPE as m}from"@autofleet/common-types/lib/custom-fields";const{CUSTOM_FIELDS_FILTER_SCOPE:h}=p,g=(t,n,r={useCustomFieldsEntries:!1})=>{t.forEach(async({name:t,scopeAttributes:u,modelOptions:d})=>{try{let p=n(t);if(!p){e.warn(`sadot - tried to addHooks to a model that does not exist yet`,{name:t,scopeAttributes:u});return}p.rawAttributes.customFields={type:f.VIRTUAL},p.refreshAttributes(),p.addHook(`beforeFind`,`sadot-beforeFind`,a(u)),p.addHook(`beforeBulkCreate`,`sadot-beforeBulkCreate`,o),p.addHook(`beforeBulkUpdate`,`sadot-beforeBulkUpdate`,s),p.addHook(`beforeCreate`,`sadot-beforeCreate`,c(u,d,r)),p.addHook(`beforeUpdate`,`sadot-beforeUpdate`,l(u,d,r)),p.addHook(`afterFind`,`sadot-afterFind`,i(t,u,`afterFind`,d,r)),p.addHook(`afterUpdate`,`sadot-afterUpdate`,i(t,u,void 0,d,r)),p.addHook(`afterCreate`,`sadot-afterCreate`,i(t,u,void 0,d,r))}catch(n){e.error(`Could not add custom fields hook to model ${t}. `,n)}})},_=(t,n)=>{t.forEach(async({name:t})=>{try{let e=n(t);if(!e)return;e.rawAttributes.customFields&&(delete e.rawAttributes.customFields,e.refreshAttributes()),e.removeHook(`beforeFind`,`sadot-beforeFind`),e.removeHook(`beforeBulkCreate`,`sadot-beforeBulkCreate`),e.removeHook(`beforeBulkUpdate`,`sadot-beforeBulkUpdate`),e.removeHook(`beforeCreate`,`sadot-beforeCreate`),e.removeHook(`beforeUpdate`,`sadot-beforeUpdate`),e.removeHook(`afterFind`,`sadot-afterFind`),e.removeHook(`afterUpdate`,`sadot-afterUpdate`)}catch(n){e.error(`Could not add custom fields hook to model ${t}. `,n)}})},v=(e,t,r)=>{r?.useCustomFieldsEntries||(e.hasMany(n,{foreignKey:`modelId`,as:`customFieldValue`}),n.belongsTo(e,{foreignKey:`modelId`,as:t}))},y=(t,n,r={useCustomFieldsEntries:!1})=>{t.forEach(async({name:t,scopeAttributes:i})=>{try{let a=n(t);if(!a){e.warn(`sadot - tried to addScopes to a model that does not exist yet`,{name:t,scopeAttributes:i});return}v(a,t,r),a.addScope(h,u(t,r)),a.addScope(m,d(t,r))}catch(n){e.error(`Could not add custom fields scopes to model ${t}. `,n)}})},b=e=>{e.forEach(({modelOptions:e})=>{e?.customAssociation?.(t),e?.customAssociation?.(r)})};export{g as addHooks,y as addScopes,b as applyCustomAssociation,_ as removeHooks};
-//# sourceMappingURL=init.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.applyCustomAssociation = exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
+const sequelize_1 = require("sequelize");
+const common_types_1 = require("@autofleet/common-types");
+const custom_fields_1 = require("@autofleet/common-types/lib/custom-fields");
+const models_1 = require("../models");
+const hooks_1 = require("../hooks");
+const scopes_1 = require("../scopes");
+const logger_1 = __importDefault(require("./logger"));
+const filter_1 = require("../scopes/filter");
+const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
+const addHooks = (models, getModel, sadotOptions = { useCustomFieldsEntries: false }) => {
+    models.forEach(async ({ name, scopeAttributes, modelOptions, }) => {
+        try {
+            const model = getModel(name);
+            if (!model) {
+                logger_1.default.warn('sadot - tried to addHooks to a model that does not exist yet', {
+                    name,
+                    scopeAttributes,
+                });
+                return;
+            }
+            model.rawAttributes.customFields = {
+                type: sequelize_1.DataTypes.VIRTUAL,
+            };
+            model.refreshAttributes();
+            // TODO: Uncomment after tests are passed
+            // model.addHook('afterFind', workaround);
+            model.addHook('beforeFind', 'sadot-beforeFind', (0, hooks_1.beforeFind)(scopeAttributes));
+            model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', hooks_1.beforeBulkCreate);
+            model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', hooks_1.beforeBulkUpdate);
+            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes, modelOptions, sadotOptions));
+            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes, modelOptions, sadotOptions));
+            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes, 'afterFind', modelOptions, sadotOptions));
+            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions, sadotOptions));
+            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions, sadotOptions));
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
+        }
+    });
+};
+exports.addHooks = addHooks;
+const removeHooks = (models, getModel) => {
+    models.forEach(async ({ name }) => {
+        try {
+            const model = getModel(name);
+            if (!model)
+                return;
+            if (model.rawAttributes.customFields) {
+                delete model.rawAttributes.customFields;
+                model.refreshAttributes();
+            }
+            // model.removeHook('afterFind', 'sadot-workaround');
+            model.removeHook('beforeFind', 'sadot-beforeFind');
+            model.removeHook('beforeBulkCreate', 'sadot-beforeBulkCreate');
+            model.removeHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate');
+            model.removeHook('beforeCreate', 'sadot-beforeCreate');
+            model.removeHook('beforeUpdate', 'sadot-beforeUpdate');
+            model.removeHook('afterFind', 'sadot-afterFind');
+            model.removeHook('afterUpdate', 'sadot-afterUpdate');
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
+        }
+    });
+};
+exports.removeHooks = removeHooks;
+/**
+ *  Necessary associations for the {@link customFieldsFilterScope} scope
+ */
+const addAssociations = (model, modelName, options) => {
+    if (options?.useCustomFieldsEntries)
+        return;
+    model.hasMany(models_1.CustomFieldValue, { foreignKey: 'modelId', as: 'customFieldValue' });
+    // TBC: maybe can be removed
+    models_1.CustomFieldValue.belongsTo(model, { foreignKey: 'modelId', as: modelName });
+};
+const addScopes = (models, getModel, options = { useCustomFieldsEntries: false }) => {
+    models.forEach(async ({ name, scopeAttributes }) => {
+        try {
+            const model = getModel(name);
+            if (!model) {
+                logger_1.default.warn('sadot - tried to addScopes to a model that does not exist yet', {
+                    name,
+                    scopeAttributes,
+                });
+                return;
+            }
+            // Necessary associations for the filtering scope
+            addAssociations(model, name, options);
+            // Add filter scope
+            model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, (0, scopes_1.customFieldsFilterScope)(name, options));
+            model.addScope(custom_fields_1.CUSTOM_FIELDS_SORT_SCOPE, (0, filter_1.customFieldsSortScope)(name, options));
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields scopes to model ${name}. `, e);
+        }
+    });
+};
+exports.addScopes = addScopes;
+const applyCustomAssociation = (models) => {
+    models.forEach(({ modelOptions }) => {
+        modelOptions?.customAssociation?.(models_1.CustomFieldDefinition);
+        modelOptions?.customAssociation?.(models_1.CustomValidator);
+    });
+};
+exports.applyCustomAssociation = applyCustomAssociation;

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

@@ -0,0 +1,3 @@
+declare const logger: import("@autofleet/logger").LoggerInstanceManager;
+export declare function tryAddingTraceIdMiddleware(): Promise<void>;
+export default logger;

package/dist/utils/logger/index.js

@@ -1,2 +1,42 @@
-import{outbreak as e}from"@autofleet/zehut";import t from"@autofleet/logger";const n=t();function r(){n.addContextMiddleware(()=>({traceId:e.getCurrentContextTraceId()}))}var i=n;export{i as default,r as tryAddingTraceIdMiddleware};
-//# sourceMappingURL=index.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.tryAddingTraceIdMiddleware = void 0;
+const logger_1 = __importDefault(require("@autofleet/logger"));
+const logger = (0, logger_1.default)();
+async function tryAddingTraceIdMiddleware() {
+    try {
+        const { outbreak } = await Promise.resolve().then(() => __importStar(require('@autofleet/zehut')));
+        logger.addContextMiddleware(() => ({ traceId: outbreak.getCurrentContextTraceId() }));
+    }
+    catch (err) {
+        logger.error('Failed to add traceId middleware', { err });
+    }
+}
+exports.tryAddingTraceIdMiddleware = tryAddingTraceIdMiddleware;
+exports.default = logger;

package/dist/utils/scopeAttributes.d.ts

@@ -0,0 +1,2 @@
+declare const applyScopeToInstance: (instance: any, scopeAttributes: string[]) => any[];
+export default applyScopeToInstance;

package/dist/utils/scopeAttributes.js

@@ -1,2 +1,11 @@
-const e=(e,t)=>e.map(e=>t[e]);var t=(t,n)=>{let r=Array.from(new Set(n));return Array.isArray(t)?t.flatMap(t=>e(r,t)):e(r,t)};export{t as default};
-//# sourceMappingURL=scopeAttributes.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapAttributeToInstance = (scopeAttributes, instance) => scopeAttributes.map((attr) => instance[attr]);
+const applyScopeToInstance = (instance, scopeAttributes) => {
+    const uniqueAttributes = Array.from(new Set(scopeAttributes));
+    if (Array.isArray(instance)) {
+        return instance.flatMap((ins) => mapAttributeToInstance(uniqueAttributes, ins));
+    }
+    return mapAttributeToInstance(uniqueAttributes, instance);
+};
+exports.default = applyScopeToInstance;

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

@@ -0,0 +1,8 @@
+import type { CustomFieldDefinition } from '../../models';
+import type { CustomFieldEntriesDTO } from '../../types/entries';
+import type { CustomFieldDefinitionType } from '../constants';
+export declare const validateFieldType: (type: CustomFieldDefinitionType) => boolean;
+export declare const validateValue: (value: unknown, valueType: CustomFieldDefinitionType, validation?: unknown) => import("joi").ValidationResult;
+export declare const validateInstanceCustomFieldEntries: (instance: CustomFieldEntriesDTO, definitionsByName: {
+    [defName: string]: CustomFieldDefinition;
+}) => void;

package/dist/utils/validations/index.js

@@ -1,2 +1,41 @@
-import{validators as e}from"./validators/index.js";import{InvalidEntriesError as t}from"../../errors/index.js";const n=t=>Object.keys(e).includes(t),r=(t,n,r)=>{let i=e[n];return i(t,r)},i=(e,n,i=r)=>{let a=Object.entries(e.customFields).map(([e,t])=>{if(t===null)return null;let{validation:r,fieldType:a}=n[e],o=i(t,a,r);return o?.error?{joiValidationError:o.error,fieldDefinitionName:e,value:t}:null}).filter(e=>!!e);if(a?.length)throw new t(e.modelId,a)};export{n as validateFieldType,i as validateInstanceCustomFieldEntries,r as validateValue};
-//# sourceMappingURL=index.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInstanceCustomFieldEntries = exports.validateValue = exports.validateFieldType = void 0;
+const errors_1 = require("../../errors");
+const validators_1 = require("./validators");
+const validateFieldType = (type) => Object.keys(validators_1.validators).includes(type);
+exports.validateFieldType = validateFieldType;
+const validateValue = (value, valueType, validation) => {
+    const validator = validators_1.validators[valueType];
+    return validator(value, validation);
+    /** TODO: Add validation for required fields
+     * @example
+     * if (validations.required && !value) {
+     *  return false;
+     * }
+     */
+};
+exports.validateValue = validateValue;
+const validateInstanceCustomFieldEntries = (instance, definitionsByName) => {
+    const validationErrors = Object.entries(instance.customFields)
+        .map(([customFieldName, value]) => {
+        // Allow NULL values, just like we do in custom_field_values.
+        if (value === null)
+            return null;
+        const { validation, fieldType } = definitionsByName[customFieldName];
+        const result = (0, exports.validateValue)(value, fieldType, validation);
+        if (result?.error) {
+            return {
+                joiValidationError: result.error,
+                fieldDefinitionName: customFieldName,
+                value,
+            };
+        }
+        return null;
+    })
+        .filter((result) => !!result);
+    if (validationErrors?.length) {
+        throw new errors_1.InvalidEntriesError(instance.modelId, validationErrors);
+    }
+};
+exports.validateInstanceCustomFieldEntries = validateInstanceCustomFieldEntries;

package/dist/utils/validations/schema/custom-fields.d.ts

@@ -1,7 +1,3 @@
-import Joi from "joi";
-
-//#region src/utils/validations/schema/custom-fields.d.ts
-declare const CustomFieldsSchema: Joi.ObjectSchema<Record<string, any>>;
-//#endregion
+import Joi from 'joi';
+declare const CustomFieldsSchema: Joi.ObjectSchema<any>;
 export { CustomFieldsSchema };
-//# sourceMappingURL=custom-fields.d.ts.map

package/dist/utils/validations/schema/custom-fields.js

@@ -1,2 +1,9 @@
-import e from"joi";const t=e.object().pattern(e.string(),e.any());export{t as CustomFieldsSchema};
-//# sourceMappingURL=custom-fields.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.CustomFieldsSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const CustomFieldsSchema = joi_1.default.object().pattern(joi_1.default.string(), joi_1.default.any());
+exports.CustomFieldsSchema = CustomFieldsSchema;

package/dist/utils/validations/schema/validator-schema.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Validates that a given schema is a valid Ajv schema
+ * This function is used to validate schemas passed to custom validators
+ *
+ * @param schema The schema to validate
+ * @returns true if valid, throws an error if invalid
+ */
+export declare const validateValidatorSchema: (schema: Record<string, unknown>) => boolean;
+export default validateValidatorSchema;

package/dist/utils/validations/schema/validator-schema.js

@@ -1,2 +1,95 @@
-import e from"../../logger/index.js";import{BadRequest as t}from"@autofleet/errors";import n from"ajv";import r from"ajv-formats";const i=new n({allErrors:!0,strict:!1,strictTypes:!1,$data:!0});r(i);const a={type:`object`,properties:{type:{type:`string`,enum:[`object`]},properties:{type:`object`,properties:{before:{type:`object`,properties:{type:{type:`string`,enum:[`object`]},properties:{type:`object`}}},after:{type:`object`,properties:{type:{type:`string`,enum:[`object`]},properties:{type:`object`}}}}},required:{type:`array`,items:{type:`string`}},if:{type:`object`},then:{type:`object`},else:{type:`object`}},required:[`type`,`properties`]},o=n=>{try{let r=i.compile(a);if(!r(n)){let i=r.errors?.map(e=>`${e.instancePath||``} ${e.message||`Invalid schema structure`}`).join(`, `);throw e.error(`Invalid validator schema structure`,{errors:r.errors,schema:n}),new t([Error(`Invalid validator schema structure: ${i}`)],[`Invalid validator schema structure`])}try{return i.compile(n),!0}catch(r){throw e.error(`Failed to compile validator schema`,{error:r,schema:n}),new t([Error(`Failed to compile validator schema: ${r.message}`)],[`Invalid validator schema`])}}catch(r){throw r instanceof t?r:(e.error(`Error validating validator schema`,{error:r,schema:n}),new t([Error(`Error validating validator schema: ${r.message}`)],[`Invalid validator schema`]))}};export{o as validateValidatorSchema};
-//# sourceMappingURL=validator-schema.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.validateValidatorSchema = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const errors_1 = require("@autofleet/errors");
+const logger_1 = __importDefault(require("../../logger"));
+// Instantiate Ajv for meta-validation
+const metaValidator = new ajv_1.default({
+    allErrors: true,
+    strict: false,
+    strictTypes: false,
+    $data: true, // Enable $data references
+});
+(0, ajv_formats_1.default)(metaValidator);
+/**
+ * Schema for validating JSON Schema objects in custom validators
+ * This is a meta-schema to ensure that custom validator schemas are valid Ajv schemas
+ */
+const validatorMetaSchema = {
+    type: 'object',
+    properties: {
+        type: { type: 'string', enum: ['object'] },
+        properties: {
+            type: 'object',
+            properties: {
+                before: {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string', enum: ['object'] },
+                        properties: { type: 'object' },
+                    },
+                },
+                after: {
+                    type: 'object',
+                    properties: {
+                        type: { type: 'string', enum: ['object'] },
+                        properties: { type: 'object' },
+                    },
+                },
+            },
+        },
+        required: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+        if: { type: 'object' },
+        then: { type: 'object' },
+        else: { type: 'object' },
+    },
+    required: ['type', 'properties'],
+};
+/**
+ * Validates that a given schema is a valid Ajv schema
+ * This function is used to validate schemas passed to custom validators
+ *
+ * @param schema The schema to validate
+ * @returns true if valid, throws an error if invalid
+ */
+const validateValidatorSchema = (schema) => {
+    try {
+        // First validate the schema structure
+        const validateMetaSchema = metaValidator.compile(validatorMetaSchema);
+        const isValidStructure = validateMetaSchema(schema);
+        if (!isValidStructure) {
+            const errorDetails = validateMetaSchema.errors?.map((err) => `${err.instancePath || ''} ${err.message || 'Invalid schema structure'}`).join(', ');
+            logger_1.default.error('Invalid validator schema structure', {
+                errors: validateMetaSchema.errors,
+                schema,
+            });
+            throw new errors_1.BadRequest([new Error(`Invalid validator schema structure: ${errorDetails}`)], ['Invalid validator schema structure']);
+        }
+        // Then try to compile the schema with Ajv to verify it's a valid JSON Schema
+        try {
+            metaValidator.compile(schema);
+            return true;
+        }
+        catch (compileError) {
+            logger_1.default.error('Failed to compile validator schema', { error: compileError, schema });
+            throw new errors_1.BadRequest([new Error(`Failed to compile validator schema: ${compileError.message}`)], ['Invalid validator schema']);
+        }
+    }
+    catch (error) {
+        if (error instanceof errors_1.BadRequest) {
+            throw error;
+        }
+        logger_1.default.error('Error validating validator schema', { error, schema });
+        throw new errors_1.BadRequest([new Error(`Error validating validator schema: ${error.message}`)], ['Invalid validator schema']);
+    }
+};
+exports.validateValidatorSchema = validateValidatorSchema;
+exports.default = exports.validateValidatorSchema;

package/dist/utils/validations/type.d.ts

@@ -0,0 +1,15 @@
+import type { ValidationResult } from 'joi';
+import type { CustomFieldDefinitionType } from '../constants';
+/**
+ * Validator is a function that validates a custom-field `value`,
+ * against a custom-field definition `validation object`.
+ * @returns `true` if the value is valid, `false` otherwise.
+ */
+export type Validator<Value, DefinitionValidationObject> = (value: Value, validation?: DefinitionValidationObject) => ValidationResult;
+/**
+ * Validators is a map of custom-field types to their respective validators.
+ * The key is the custom-field type, and the value is the validator function.
+ */
+export type Validators = {
+    [K in CustomFieldDefinitionType]: Validator<unknown, unknown>;
+};

package/dist/utils/validations/type.js

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

package/dist/utils/validations/validators/index.d.ts

@@ -0,0 +1,14 @@
+import { CustomFieldDefinitionType } from '../../constants';
+import type { Validators } from '../type';
+/**
+ * Custom field types that must have custom validation.
+ * TODO: remove this after moving to schema-based validation
+ */
+export declare const CustomValidationTypes: {
+    readonly select: CustomFieldDefinitionType.SELECT;
+    readonly status: CustomFieldDefinitionType.STATUS;
+};
+/**
+ * Validators for custom fields
+ */
+export declare const validators: Validators;

package/dist/utils/validations/validators/index.js

@@ -1,2 +1,40 @@
-import{CustomFieldDefinitionType as e}from"../../constants/index.js";import{validateSelect as t}from"./select.validator.js";import{validateStatus as n}from"./status.validator.js";import r from"joi";const i={[e.SELECT]:e.SELECT,[e.STATUS]:e.STATUS},a={[e.SELECT]:t,[e.STATUS]:n,[e.TEXT]:e=>r.string().min(0).validate(e),[e.NUMBER]:e=>r.number().strict(!0).validate(e),[e.BOOLEAN]:e=>r.boolean().strict().validate(e),[e.DATE]:e=>r.date().validate(e),[e.DATETIME]:e=>r.date().validate(e),[e.IMAGE]:e=>r.array().min(1).unique().items(r.string().uri()).validate(e),[e.FILE]:e=>r.array().min(1).unique().items(r.object({name:r.string().required(),type:r.string(),size:r.string(),addedBy:r.string().uuid()})).validate(e)};export{i as CustomValidationTypes,a as validators};
-//# sourceMappingURL=index.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.validators = exports.CustomValidationTypes = void 0;
+const joi_1 = __importDefault(require("joi"));
+const constants_1 = require("../../constants");
+const select_validator_1 = require("./select.validator");
+const status_validator_1 = require("./status.validator");
+/**
+ * Custom field types that must have custom validation.
+ * TODO: remove this after moving to schema-based validation
+ */
+exports.CustomValidationTypes = {
+    [constants_1.CustomFieldDefinitionType.SELECT]: constants_1.CustomFieldDefinitionType.SELECT,
+    [constants_1.CustomFieldDefinitionType.STATUS]: constants_1.CustomFieldDefinitionType.STATUS,
+};
+/**
+ * Validators for custom fields
+ */
+exports.validators = {
+    [constants_1.CustomFieldDefinitionType.SELECT]: select_validator_1.validateSelect,
+    [constants_1.CustomFieldDefinitionType.STATUS]: status_validator_1.validateStatus,
+    [constants_1.CustomFieldDefinitionType.TEXT]: (value) => joi_1.default.string().min(0).validate(value),
+    [constants_1.CustomFieldDefinitionType.NUMBER]: (value) => joi_1.default.number().strict(true).validate(value),
+    [constants_1.CustomFieldDefinitionType.BOOLEAN]: (value) => joi_1.default.boolean().strict().validate(value),
+    [constants_1.CustomFieldDefinitionType.DATE]: (value) => joi_1.default.date().validate(value),
+    [constants_1.CustomFieldDefinitionType.DATETIME]: (value) => joi_1.default.date().validate(value),
+    [constants_1.CustomFieldDefinitionType.IMAGE]: (value) => joi_1.default.array().min(1).unique()
+        .items(joi_1.default.string().uri())
+        .validate(value),
+    [constants_1.CustomFieldDefinitionType.FILE]: (value) => joi_1.default.array().min(1).unique().items(joi_1.default.object({
+        name: joi_1.default.string().required(),
+        type: joi_1.default.string(),
+        size: joi_1.default.string(),
+        addedBy: joi_1.default.string().uuid(),
+    }))
+        .validate(value),
+};

package/dist/utils/validations/validators/select.validator.d.ts

@@ -0,0 +1,5 @@
+import type { Validator } from '../type';
+/**
+ * Validate that the value is one of the select values
+ */
+export declare const validateSelect: Validator<string, string[]>;

package/dist/utils/validations/validators/select.validator.js

@@ -1,2 +1,12 @@
-import e from"joi";const t=(t,n)=>e.string().allow(null).valid(...n).validate(t);export{t as validateSelect};
-//# sourceMappingURL=select.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.validateSelect = void 0;
+const joi_1 = __importDefault(require("joi"));
+/**
+ * Validate that the value is one of the select values
+ */
+const validateSelect = (value, selectValues) => (joi_1.default.string().allow(null).valid(...selectValues).validate(value));
+exports.validateSelect = validateSelect;

package/dist/utils/validations/validators/status.validator.d.ts

@@ -0,0 +1,12 @@
+import type { Validator } from '../type';
+type StatusColor = string | null;
+type StatusValue = string;
+type StatusOption = {
+    value: StatusValue;
+    color: StatusColor;
+};
+/**
+* Validate that the value is one of the status values
+*/
+export declare const validateStatus: Validator<StatusValue, StatusOption[]>;
+export {};