@autofleet/sadot 1.0.0-beta.1 → 1.0.0

package/dist/types/index.d.ts

@@ -1,6 +1,15 @@
-import type { IncludeOptions } from 'sequelize';
-import type { ModelCtor } from 'sequelize-typescript';
+import type { IncludeOptions, Transaction } from 'sequelize';
+import type { ModelCtor, Sequelize } from 'sequelize-typescript';
+import type { getUser as GetUserType } from '@autofleet/zehut';
+import type CustomFieldDefinition from '../models/CustomFieldDefinition';
+import type CustomValidator from '../models/CustomValidator';
 export type ModelFetcher = (name: string) => any;
+export interface TransactionOptions extends Record<string, any> {
+    transaction?: Transaction & {
+        definitionCache?: Map<string, CustomFieldDefinition[]>;
+        validationsCache?: Map<string, CustomValidator[]>;
+    };
+}
 export type ModelOptions = {
     /**
      * Include options for the model
@@ -15,6 +24,10 @@ export type ModelOptions = {
      * Whether to use the entity id  from the instance per scope attribute
      */
     useEntityIdFromInclude?: boolean;
+    /**
+     * Which attributes to include in the model
+     */
+    attributes?: string[];
 };
 export type Models = {
     name: string;
@@ -27,5 +40,8 @@ export type Models = {
 export type CustomFieldOptions = {
     models: Models[];
     databaseConfig: any;
-    getUser: () => any;
+    getUser: typeof GetUserType;
+    sequelize?: Sequelize;
+    useCustomFieldsEntries?: boolean;
+    useValidators?: boolean;
 };

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

@@ -1,4 +1,4 @@
-declare const CUSTOM_FIELDS_FILTER_SCOPE: string;
+declare const CUSTOM_FIELDS_FILTER_SCOPE: "filterByCustomFields";
 export declare const supportedEntities: string[];
 /**
  * Supported custom field types

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

@@ -1,4 +1,4 @@
-import { type WhereOptions, type IncludeOptions } from 'sequelize';
+import { type WhereOptions, type BindOrReplacements } from 'sequelize';
 import { type ModelStatic } from 'sequelize-typescript';
 import { CustomFieldDefinitionType } from '../constants';
 /**
@@ -14,11 +14,12 @@ import { CustomFieldDefinitionType } from '../constants';
  * @param {CustomFieldDefinitionType[]} excludedCustomFieldsTypes - An array of custom field types
  * to exclude from the search
  *
- * @returns {CustomFieldsSearchPayload} - An object containing the INCLUDE clause and WHERE clause to add to query payload
+ * @returns {CustomFieldsSearchPayload} - An object containing the WHERE clause and replacements
+ * for Sequelize.
  */
 interface CustomFieldsSearchPayload {
     where: WhereOptions;
-    include: IncludeOptions[];
+    replacements: BindOrReplacements;
 }
 export declare const generateRandomString: (length?: number) => string;
 export declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;

package/dist/utils/helpers/index.js

@@ -6,7 +6,6 @@ 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 models_1 = require("../../models");
 const generateRandomString = (length = 5) => {
     const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
     return Array.from({ length }, () => characters.charAt((0, node_crypto_1.randomInt)(characters.length))).join('');
@@ -15,34 +14,27 @@ exports.generateRandomString = generateRandomString;
 const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
     constants_1.CustomFieldDefinitionType.DATETIME,
     constants_1.CustomFieldDefinitionType.DATE,
-]) => ({
-    include: [{
-            attributes: ['value', 'model_id'],
-            model: models_1.CustomFieldValue,
-            as: 'customFieldValue',
-            required: false,
-            include: [
-                {
-                    model: models_1.CustomFieldDefinition,
-                    as: 'customFieldDefinition',
-                    attributes: ['entity_id', 'field_type', 'model_type'],
-                    required: true,
-                    on: {
-                        id: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('id'), { [sequelize_1.Op.eq]: sequelize_typescript_1.Sequelize.col('customFieldValue.custom_field_definition_id') }),
-                        entityId: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('entity_id'), { [sequelize_1.Op.eq]: `${entityId}` }),
-                        modelType: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('model_type'), { [sequelize_1.Op.eq]: `${model.name}` }),
-                        fieldType: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('field_type'), { [sequelize_1.Op.notIn]: customFieldsTypesToExclude }),
-                    },
-                    where: {
-                        deleted_at: null,
-                    },
-                },
+]) => {
+    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),
             ],
-            on: {
-                value: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.cast(sequelize_typescript_1.Sequelize.col('value'), 'text'), { [sequelize_1.Op.iLike]: `%${searchTerm}%` }),
-                model_id: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('model_id'), { [sequelize_1.Op.eq]: sequelize_typescript_1.Sequelize.col(`${model.name}.id`) }),
-            },
-        }],
-    where: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('customFieldValue.model_id'), { [sequelize_1.Op.not]: null }),
-});
+        },
+        replacements: { searchTerm: `%${searchTerm}%` },
+    };
+};
 exports.generateCustomFieldSearchQueryPayload = generateCustomFieldSearchQueryPayload;

package/dist/utils/init.d.ts

@@ -1,5 +1,7 @@
-import type { ModelFetcher, Models } from '../types';
-export declare const addHooks: (models: Models[], getModel: ModelFetcher) => void;
+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) => 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

@@ -13,7 +13,7 @@ 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) => {
+const addHooks = (models, getModel, sadotOptions = { useCustomFieldsEntries: false }) => {
     models.forEach(async ({ name, scopeAttributes, modelOptions, }) => {
         try {
             const model = getModel(name);
@@ -33,11 +33,11 @@ const addHooks = (models, getModel) => {
             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));
-            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes, modelOptions));
-            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes, 'afterFind', modelOptions));
-            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
-            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
+            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);
@@ -73,12 +73,14 @@ exports.removeHooks = removeHooks;
 /**
  *  Necessary associations for the {@link customFieldsFilterScope} scope
  */
-const addAssociations = (model, modelName) => {
+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) => {
+const addScopes = (models, getModel, options = { useCustomFieldsEntries: false }) => {
     models.forEach(async ({ name, scopeAttributes }) => {
         try {
             const model = getModel(name);
@@ -90,10 +92,10 @@ const addScopes = (models, getModel) => {
                 return;
             }
             // Necessary associations for the filtering scope
-            addAssociations(model, name);
+            addAssociations(model, name, options);
             // Add filter scope
-            model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, (0, scopes_1.customFieldsFilterScope)(name));
-            model.addScope(custom_fields_1.CUSTOM_FIELDS_SORT_SCOPE, (0, filter_1.customFieldsSortScope)(name));
+            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);

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

@@ -1,2 +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,8 +1,42 @@
 "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/validations/index.d.ts

@@ -1,2 +1,8 @@
+import type { CustomFieldDefinition } from '../../models';
+import type { CustomFieldEntriesDTO } from '../../types/entries';
 import type { CustomFieldDefinitionType } from '../constants';
-export declare const validateValue: (value: unknown, valueType: CustomFieldDefinitionType, validation?: unknown) => boolean;
+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,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateValue = void 0;
+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];
-    if (!validator) {
-        // Unsupported field type
-        return false;
-    }
-    // Always allow null values
-    return value === null || validator(value, validation);
+    return validator(value, validation);
     /** TODO: Add validation for required fields
      * @example
      * if (validations.required && !value) {
@@ -18,3 +16,26 @@ const validateValue = (value, valueType, validation) => {
      */
 };
 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/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

@@ -0,0 +1,95 @@
+"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

@@ -1,10 +1,11 @@
+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) => boolean;
+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.

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

@@ -22,19 +22,19 @@ exports.CustomValidationTypes = {
 exports.validators = {
     [constants_1.CustomFieldDefinitionType.SELECT]: select_validator_1.validateSelect,
     [constants_1.CustomFieldDefinitionType.STATUS]: status_validator_1.validateStatus,
-    [constants_1.CustomFieldDefinitionType.TEXT]: (value) => (typeof value === 'string'),
-    [constants_1.CustomFieldDefinitionType.NUMBER]: (value) => (typeof value === 'number'),
-    [constants_1.CustomFieldDefinitionType.BOOLEAN]: (value) => (typeof value === 'boolean'),
-    [constants_1.CustomFieldDefinitionType.DATE]: (value) => (!joi_1.default.date().validate(value).error),
-    [constants_1.CustomFieldDefinitionType.DATETIME]: (value) => (!joi_1.default.date().validate(value).error),
-    [constants_1.CustomFieldDefinitionType.IMAGE]: (value) => (!joi_1.default.array().min(1).unique()
+    [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).error),
-    [constants_1.CustomFieldDefinitionType.FILE]: (value) => (!joi_1.default.array().min(1).unique().items(joi_1.default.object({
+        .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).error),
+        .validate(value),
 };

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

@@ -1,9 +1,12 @@
 "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) => (Array.isArray(selectValues)
-    && selectValues.includes(value));
+const validateSelect = (value, selectValues) => (joi_1.default.string().allow(null).valid(...selectValues).validate(value));
 exports.validateSelect = validateSelect;

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

@@ -1,9 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateStatus = void 0;
+const joi_1 = __importDefault(require("joi"));
 /**
 * Validate that the value is one of the status values
 */
-const validateStatus = (value, statusValues) => (Array.isArray(statusValues)
-    && statusValues.some((status) => status.value === value));
+const validateStatus = (value, statusValues) => (joi_1.default.string()
+    .allow(null)
+    .valid(...statusValues.map((statusValue) => statusValue.value))
+    .validate(value));
 exports.validateStatus = validateStatus;

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@autofleet/sadot",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
     "start": "ts-node src/index.ts",
     "build": "rm -rf dist && tsc",
     "linter": "eslint .",
-    "test": "jest --forceExit --runInBand",
-    "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
+    "test": "jest --runInBand",
+    "test-debug": "node --inspect-brk node_modules/.bin/jest --testTimeout=10000000",
+    "coverage": "jest --coverage --runInBand",
     "build-to-local-repo": "node --run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
     "dev": "nodemon",
     "watch": "npm-watch build-to-local-repo",
@@ -27,11 +28,12 @@
     }
   },
   "dependencies": {
-    "@autofleet/common-types": "^1.7.58",
-    "@autofleet/errors": "^1.2.3",
-    "@autofleet/events": "^2.0.0",
-    "@autofleet/logger": "^4.1.0",
-    "express": "^4.18.2",
+    "@autofleet/common-types": "^4.4.0",
+    "@autofleet/events": "^5.2.0",
+    "ajv": "^8.12.0",
+    "ajv-errors": "^3.0.0",
+    "ajv-formats": "^3.0.1",
+    "http-status-codes": "^2.3.0",
     "joi": "^17.7.0",
     "pg": "^8.10.0",
     "reflect-metadata": "^0.1.13",
@@ -39,6 +41,10 @@
     "sequelize-typescript": "^2.1.5"
   },
   "devDependencies": {
+    "@autofleet/errors": "^3.0.1",
+    "@autofleet/logger": "^4.2.1",
+    "@autofleet/node-common": "^4.0.2",
+    "@autofleet/zehut": "^4.0.1",
     "@types/express": "^4.17.17",
     "@types/jest": "^29.5.13",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
@@ -46,18 +52,28 @@
     "eslint": "^8.57.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-plugin-import": "^2.22.1",
+    "express": "^4.21.2",
     "jest": "^29.7.0",
     "npm-watch": "^0.11.0",
+    "supertest": "^7.0.0",
     "ts-jest": "^29.1.2",
     "ts-node": "^8.6.2",
-    "typescript": "^5.3.3",
-    "typescript-eslint": "^0.0.1-alpha.0"
+    "typescript": "^5.3.3"
   },
   "peerDependencies": {
-    "@autofleet/sheilta": ">=1.4.0"
+    "@autofleet/errors": "^3",
+    "@autofleet/logger": "^4",
+    "@autofleet/node-common": "^4",
+    "@autofleet/sheilta": "^2",
+    "@autofleet/zehut": "^4"
+  },
+  "peerDependenciesMeta": {
+    "@autofleet/zehut": {
+      "optional": true
+    }
   },
   "engines": {
-    "node": ">=16.0.0"
+    "node": ">=18.0.0"
   },
   "author": "Autofleet",
   "license": "ISC"

package/src/api/index.ts

@@ -1,8 +1,9 @@
 // export the api object
-import { Router } from 'express';
+import { Router } from '@autofleet/node-common';
 import v1 from './v1';
+import logger from '../utils/logger';
 
-const router = Router({ mergeParams: true });
+const router = Router({ logger });
 
 router.use('/v1', v1);