@autofleet/sadot 0.12.0 → 0.13.0-beta.0

package/src/repository/validator.ts

@@ -0,0 +1,91 @@
+import type { Transactionable } from 'sequelize';
+import logger from '../utils/logger';
+import { CustomValidator } from '../models';
+
+export interface FindValidatorOptions extends Transactionable {
+  withDisabled?: boolean;
+}
+
+// Make sure this interface is compatible with the Sequelize model
+export interface ValidatorAttributes {
+  entityId: string;
+  entityType: string;
+  modelType: string;
+  schema: Record<string, unknown>;
+  disabled?: boolean;
+  [key: string]: unknown; // Add index signature for Sequelize compatibility
+}
+
+export const create = async (
+  validatorAttributes: ValidatorAttributes,
+  options: Transactionable = {},
+): Promise<CustomValidator> => {
+  logger.debug('custom-validator - create validator');
+
+  // Use unknown type to bypass TypeScript errors while maintaining compatibility
+  const validator = await CustomValidator.create(validatorAttributes as Record<string, unknown>, options);
+
+  return validator;
+};
+
+export const findAll = async (
+  where = {},
+  options: FindValidatorOptions = { withDisabled: false },
+): Promise<CustomValidator[]> => {
+  logger.debug('custom-validator - find all validators');
+
+  const { transaction, withDisabled } = options;
+
+  const fullWhere = withDisabled
+    ? where
+    : { ...where, disabled: false };
+
+  const validators = await CustomValidator.findAll({
+    where: fullWhere,
+    transaction,
+  });
+
+  return validators;
+};
+
+export const findAllByModelType = async (
+  modelType: string,
+  entityId: string,
+  options: FindValidatorOptions = { withDisabled: false },
+): Promise<CustomValidator[]> => {
+  logger.debug('custom-validator - find all validators by model type');
+
+  return findAll(
+    {
+      modelType,
+      entityId,
+    },
+    options,
+  );
+};
+
+export const update = async (
+  id: string,
+  updates: Partial<ValidatorAttributes>,
+  options?: Transactionable,
+): Promise<[number, CustomValidator[]]> => {
+  logger.debug('custom-validator - update validator');
+
+  return CustomValidator.update(
+    updates,
+    {
+      where: { id },
+      returning: true,
+      ...options,
+    },
+  );
+};
+
+export const disable = async (
+  id: string,
+  options?: Transactionable,
+): Promise<[number, CustomValidator[]]> => {
+  logger.debug('custom-validator - disable validator');
+
+  return update(id, { disabled: true }, options);
+};

package/src/tests/helpers/commonHooks.ts

@@ -9,7 +9,10 @@ import type { Models } from '../../types';
 export function commonTestHooks(
   app: Application | null = null,
   models: Models[] = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }],
-  options: { useCustomFieldsEntries: boolean } = { useCustomFieldsEntries: false },
+  options: { useCustomFieldsEntries: boolean, useValidators?: boolean } = {
+    useCustomFieldsEntries: false,
+    useValidators: false,
+  },
 ) {
   let sequelize: Sequelize;
 
@@ -22,12 +25,16 @@ export function commonTestHooks(
       getUser: () => undefined,
       sequelize,
       useCustomFieldsEntries: options.useCustomFieldsEntries,
+      useValidators: options.useValidators,
     });
   });
 
   afterEach(async () => {
     jest.clearAllMocks();
-    await cleanup({ useCustomFieldsEntries: options.useCustomFieldsEntries });
+    await cleanup({
+      useCustomFieldsEntries: options.useCustomFieldsEntries,
+      useValidators: options.useValidators,
+    });
   });
 
   afterAll(async () => {

package/src/tests/helpers/index.ts

@@ -1,11 +1,11 @@
 import { generateFilterReplacements } from '@autofleet/sheilta';
 import {
-  ContextAwareTestModel, ContextTestModel, CustomFieldDefinition, CustomFieldEntries, TestModel,
+  ContextAwareTestModel, ContextTestModel, CustomFieldDefinition, CustomFieldEntries, CustomValidator, TestModel,
 } from '../../models';
 import type { CustomFieldOptions } from '../../types';
 
 // eslint-disable-next-line import/prefer-default-export
-export const cleanup = async (options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>): Promise<void> => {
+export const cleanup = async (options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries' | 'useValidators'>): Promise<void> => {
   if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
     await CustomFieldDefinition.unscoped().destroy({ where: {} });
     await TestModel.destroy({ where: {} });
@@ -15,6 +15,11 @@ export const cleanup = async (options?: Pick<CustomFieldOptions, 'useCustomField
     if (options?.useCustomFieldsEntries) {
       await CustomFieldEntries.unscoped().destroy({ where: {} });
     }
+
+    // Clean up validators if they were used
+    if (options?.useValidators) {
+      await CustomValidator.unscoped().destroy({ where: {} });
+    }
   }
 };
 

package/src/types/index.ts

@@ -35,4 +35,5 @@ export type CustomFieldOptions = {
   getUser: typeof GetUserType;
   sequelize?: Sequelize;
   useCustomFieldsEntries?: boolean;
+  useValidators?: boolean;
 };

package/src/utils/validations/schema/README.md

@@ -0,0 +1,93 @@
+# Schema Validation
+
+This directory contains schema validation utilities for the Sadot library, including:
+
+1. **Custom Fields Schemas** - Schema definitions for custom field validation
+2. **Validator Schemas** - Meta-validation for custom validator JSON schemas
+
+## Custom Fields Schema
+
+`custom-fields.ts` defines JSON Schema validation for custom field definitions, ensuring fields are created with valid configurations.
+
+## Validator Schema Validation
+
+`validator-schema.ts` provides meta-validation for custom validator schemas. It ensures that:
+
+1. The validator schema follows the expected structure
+2. The schema is a valid JSON Schema that can be compiled by AJV
+3. The validation rules defined in the schema are syntactically correct
+
+### Usage
+
+The `validateValidatorSchema` function is used by the custom validator API to validate schemas at creation and update time:
+
+```typescript
+import { validateValidatorSchema } from '../utils/validations/schema/validator-schema';
+
+// Validates a schema, throws BadRequest if invalid
+validateValidatorSchema(schema);
+```
+
+### Schema Structure
+
+Validator schemas must follow this general structure:
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "before": {
+      "type": "object",
+      "properties": {
+        // Model properties to validate before update
+      }
+    },
+    "after": {
+      "type": "object", 
+      "properties": {
+        // Model properties to validate after update/create
+      }
+    }
+  }
+}
+```
+
+For create operations, only the `after` section is used. For update operations, both `before` and `after` can be used.
+
+### Conditional Validation
+
+The schema can include conditional validation using JSON Schema's `if/then/else` constructs:
+
+```json
+{
+  "type": "object",
+  "if": {
+    "properties": {
+      "before": {
+        "properties": {
+          "status": { "const": "PENDING" }
+        }
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "after": {
+        "properties": {
+          "status": { "enum": ["APPROVED", "REJECTED"] }
+        }
+      }
+    }
+  }
+}
+```
+
+This example validates that if a model's status was "PENDING", it can only be updated to "APPROVED" or "REJECTED".
+
+### Error Handling
+
+Schema validation errors are thrown as BadRequest errors with descriptive messages indicating:
+
+1. The specific validation error in the schema
+2. The path within the schema where the error occurred
+3. A readable message for API consumers

package/src/utils/validations/schema/validator-schema.ts

@@ -0,0 +1,103 @@
+import Ajv from 'ajv';
+import { BadRequest } from '@autofleet/errors';
+import logger from '../../logger';
+
+// Instantiate Ajv for meta-validation
+const metaValidator = new Ajv({
+  allErrors: true,
+  strict: false,
+  strictTypes: false,
+});
+
+/**
+ * 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
+ */
+export const validateValidatorSchema = (schema: Record<string, unknown>): boolean => {
+  try {
+    // First validate the schema structure
+    const validateMetaSchema = metaValidator.compile(validatorMetaSchema);
+    const isValidStructure = validateMetaSchema(schema);
+
+    if (!isValidStructure) {
+      const errorDetails = validateMetaSchema.errors?.map((err) =>
+        `${(err as unknown as { instancePath: string }).instancePath || ''} ${(err as unknown as { message: string }).message || 'Invalid schema structure'}`).join(', ');
+
+      logger.error('Invalid validator schema structure', {
+        errors: validateMetaSchema.errors,
+        schema,
+      });
+
+      throw new 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.error('Failed to compile validator schema', { error: compileError, schema });
+
+      throw new BadRequest(
+        [new Error(`Failed to compile validator schema: ${(compileError as Error).message}`)],
+        ['Invalid validator schema'],
+      );
+    }
+  } catch (error) {
+    if (error instanceof BadRequest) {
+      throw error;
+    }
+
+    logger.error('Error validating validator schema', { error, schema });
+    throw new BadRequest(
+      [new Error(`Error validating validator schema: ${(error as Error).message}`)],
+      ['Invalid validator schema'],
+    );
+  }
+};
+
+export default validateValidatorSchema;

package/dist/api/index.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="express" />
-declare const router: import("express").Router;
-export default router;

package/dist/api/index.js

@@ -1,12 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// export the api object
-const node_common_1 = require("@autofleet/node-common");
-const v1_1 = __importDefault(require("./v1"));
-const logger_1 = __importDefault(require("../utils/logger"));
-const router = (0, node_common_1.Router)({ logger: logger_1.default });
-router.use('/v1', v1_1.default);
-exports.default = router;

package/dist/api/v1/definition/index.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="express" />
-declare const router: import("express").Router;
-export default router;

package/dist/api/v1/definition/index.js

@@ -1,116 +0,0 @@
-"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 });
-const errors_1 = require("@autofleet/errors");
-const node_common_1 = require("@autofleet/node-common");
-const errors_2 = __importDefault(require("../errors"));
-const DefinitionRepo = __importStar(require("../../../repository/definition"));
-const validations_1 = require("./validations");
-const logger_1 = __importDefault(require("../../../utils/logger"));
-const router = (0, node_common_1.Router)({ logger: logger_1.default });
-const ENTITY = 'CustomFieldDefinition';
-const toPascalCase = (str) => str.replace(/(^\w|-\w)/g, (subStr) => subStr.replace(/-/, '').toUpperCase());
-/**
- * Create
- */
-router.post('/', async (req, res) => {
-    const { modelName } = req.params;
-    const modelType = toPascalCase(modelName);
-    try {
-        const validatedPayload = await (0, validations_1.validateCustomFieldDefinitionCreation)(req.body);
-        const customFieldDefinition = await DefinitionRepo.create({
-            ...validatedPayload,
-            modelType,
-        });
-        return res.status(201).json(customFieldDefinition);
-    }
-    catch (err) {
-        logger_1.default.error('Failed to create custom field definition', err);
-        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in create ${ENTITY} request` });
-    }
-});
-/**
- * Get by id
- */
-router.get('/:customFieldDefinitionId', async (req, res) => {
-    const { customFieldDefinitionId } = req.params;
-    try {
-        const customFieldDefinition = await DefinitionRepo.findById(customFieldDefinitionId);
-        if (!customFieldDefinition) {
-            throw new errors_1.ResourceNotFoundError();
-        }
-        return res.json(customFieldDefinition);
-    }
-    catch (err) {
-        logger_1.default.error('Failed to fetch custom field definition', err);
-        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get ${ENTITY} request` });
-    }
-});
-/**
- * Get all
- */
-router.get('/', async (req, res) => {
-    const { params: { modelName }, query: { entityIds } } = req;
-    const modelType = toPascalCase(modelName);
-    try {
-        const where = {
-            modelType,
-            ...(entityIds?.length > 0 && { entityId: entityIds }),
-        };
-        const customFieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true });
-        return res.json(customFieldDefinitions);
-    }
-    catch (err) {
-        logger_1.default.error('Failed to fetch custom field definitions', err);
-        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get all ${ENTITY} request` });
-    }
-});
-/**
- * Update
- */
-router.patch('/:customFieldDefinitionId', async (req, res) => {
-    const { customFieldDefinitionId, modelName } = req.params;
-    const modelType = toPascalCase(modelName);
-    try {
-        const validatedPayload = await (0, validations_1.validateCustomFieldDefinitionUpdate)(req.body);
-        const customFieldDefinition = await DefinitionRepo.findByWhere({
-            id: customFieldDefinitionId,
-            modelType,
-        });
-        if (!customFieldDefinition) {
-            throw new errors_1.ResourceNotFoundError();
-        }
-        const updatedCustomFieldDefinition = await DefinitionRepo.update(customFieldDefinitionId, { ...validatedPayload, modelType });
-        return res.status(200).json(updatedCustomFieldDefinition);
-    }
-    catch (err) {
-        logger_1.default.error('Failed to patch custom field definition', err);
-        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in update ${ENTITY} request` });
-    }
-});
-exports.default = router;

package/dist/api/v1/definition/validations.d.ts

@@ -1,2 +0,0 @@
-export declare const validateCustomFieldDefinitionCreation: (payload: any) => Promise<any>;
-export declare const validateCustomFieldDefinitionUpdate: (payload: any) => Promise<any>;

package/dist/api/v1/definition/validations.js

@@ -1,77 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateCustomFieldDefinitionUpdate = exports.validateCustomFieldDefinitionCreation = void 0;
-/* eslint-disable newline-per-chained-call */
-const joi_1 = __importDefault(require("joi"));
-const constants_1 = require("../../../utils/constants");
-const FileValidationSchema = 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(),
-});
-const statusValidationObject = joi_1.default.object({
-    value: joi_1.default.string().required(),
-    color: joi_1.default.string().required(),
-});
-/**
- * Schema for the validation of custom field definition
- * The only custom validation is for
- * {@link CustomFieldDefinitionType.SELECT SELECT}
- * and
- * {@link CustomFieldDefinitionType.STATUS STATUS}
- * field types.
- * The rest of the field types are validated by Joi
- */
-const ValidationSchema = joi_1.default.when('fieldType', {
-    is: constants_1.CustomFieldDefinitionType.SELECT,
-    then: joi_1.default.array().required().items(joi_1.default.string()).min(1).unique(),
-    otherwise: joi_1.default.when('fieldType', {
-        is: constants_1.CustomFieldDefinitionType.STATUS,
-        then: joi_1.default.array().required().items(statusValidationObject).min(1).unique('value'),
-        otherwise: joi_1.default.forbidden(),
-    }),
-});
-const DefaultValueSchema = joi_1.default.when('fieldType', {
-    switch: [
-        { is: constants_1.CustomFieldDefinitionType.BOOLEAN, then: joi_1.default.boolean().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.DATE, then: joi_1.default.date().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.DATETIME, then: joi_1.default.date().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.FILE, then: joi_1.default.array().items(FileValidationSchema).allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.IMAGE, then: joi_1.default.array().items(joi_1.default.string().uri()).allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.NUMBER, then: joi_1.default.number().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.SELECT, then: joi_1.default.string().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.STATUS, then: joi_1.default.string().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.TEXT, then: joi_1.default.string().allow(null) },
-    ],
-});
-const CustomFieldDefinitionCreationSchema = joi_1.default.object({
-    name: joi_1.default.string().required(),
-    displayName: joi_1.default.string().required(),
-    validation: ValidationSchema,
-    defaultValue: DefaultValueSchema,
-    fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)).required(),
-    entityId: joi_1.default.string().guid().required(),
-    entityType: joi_1.default.string().required(),
-    description: joi_1.default.string(),
-    required: joi_1.default.boolean(),
-    disabled: joi_1.default.boolean(),
-    blockEditingFromUI: joi_1.default.boolean(),
-}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
-const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
-    displayName: joi_1.default.string(),
-    validation: ValidationSchema,
-    defaultValue: DefaultValueSchema,
-    fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)),
-    description: joi_1.default.string().allow(null),
-    required: joi_1.default.boolean(),
-    disabled: joi_1.default.boolean(),
-    blockEditingFromUI: joi_1.default.boolean(),
-}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
-const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
-exports.validateCustomFieldDefinitionCreation = validateCustomFieldDefinitionCreation;
-const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });
-exports.validateCustomFieldDefinitionUpdate = validateCustomFieldDefinitionUpdate;

package/dist/api/v1/errors.d.ts

@@ -1,4 +0,0 @@
-import type { Response } from 'express';
-import { type LogPayload } from '@autofleet/errors';
-declare const _default: (err: any, res: Response, additionalData?: LogPayload) => void;
-export default _default;

package/dist/api/v1/errors.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("@autofleet/errors");
-const joi_1 = require("joi");
-const sequelize_1 = require("sequelize");
-exports.default = (err, res, additionalData = undefined) => {
-    let error = err;
-    if ([joi_1.ValidationError, sequelize_1.ValidationError].some((ErrClass) => err instanceof ErrClass)) {
-        error = new errors_1.BadRequest([err], null);
-    }
-    return (0, errors_1.handleError)(error, res, additionalData);
-};

package/dist/api/v1/index.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="express" />
-declare const router: import("express").Router;
-export default router;

package/dist/api/v1/index.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_common_1 = require("@autofleet/node-common");
-const logger_1 = __importDefault(require("../../utils/logger"));
-const definition_1 = __importDefault(require("./definition"));
-const router = (0, node_common_1.Router)({ logger: logger_1.default });
-router.use('/custom-field-definitions/:modelName', definition_1.default);
-exports.default = router;

package/dist/errors/index.d.ts

@@ -1,24 +0,0 @@
-import { BadRequest } from '@autofleet/errors';
-import type { ValidationError } from 'joi';
-import type { EntriesValidationError } from '../types/entries';
-export declare class MissingRequiredCustomFieldError extends BadRequest {
-    constructor(missingFields: string[]);
-}
-export declare class UnsupportedCustomFieldTypeError extends BadRequest {
-    constructor(fieldType: string);
-}
-export declare class UnsupportedCustomValidationError extends BadRequest {
-    constructor(fieldType: string);
-}
-export declare class InvalidFieldTypeError extends BadRequest {
-    constructor(fieldType: string);
-}
-export declare class InvalidValueError extends BadRequest {
-    constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError);
-}
-export declare class InvalidEntriesError extends BadRequest {
-    constructor(modelId: string, validationErrors: EntriesValidationError[]);
-}
-export declare class MissingDefinitionError extends BadRequest {
-    constructor(fieldNames: string[]);
-}