@autofleet/sadot 1.1.7-beta → 1.1.8

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

@@ -1,106 +0,0 @@
-import Ajv from 'ajv';
-import addFormats from 'ajv-formats';
-import { BadRequest } from '@autofleet/errors';
-import logger from '../../logger';
-
-// Instantiate Ajv for meta-validation
-const metaValidator = new Ajv({
-  allErrors: true,
-  strict: false,
-  strictTypes: false,
-  $data: true, // Enable $data references
-});
-addFormats(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
- */
-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/src/utils/validations/type.ts

@@ -1,20 +0,0 @@
-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/src/utils/validations/validators/index.ts

@@ -1,38 +0,0 @@
-import Joi from 'joi';
-import { CustomFieldDefinitionType } from '../../constants';
-import type { Validators } from '../type';
-import { validateSelect } from './select.validator';
-import { validateStatus } from './status.validator';
-
-type CustomValidationTypes = Extract<CustomFieldDefinitionType, 'select' | 'status'>;
-/**
- * Custom field types that must have custom validation.
- * TODO: remove this after moving to schema-based validation
- */
-export const CustomValidationTypes = {
-  [CustomFieldDefinitionType.SELECT]: CustomFieldDefinitionType.SELECT,
-  [CustomFieldDefinitionType.STATUS]: CustomFieldDefinitionType.STATUS,
-} as const;
-
-/**
- * Validators for custom fields
- */
-export const validators: Validators = {
-  [CustomFieldDefinitionType.SELECT]: validateSelect,
-  [CustomFieldDefinitionType.STATUS]: validateStatus,
-  [CustomFieldDefinitionType.TEXT]: (value) => Joi.string().min(0).validate(value),
-  [CustomFieldDefinitionType.NUMBER]: (value) => Joi.number().strict(true).validate(value),
-  [CustomFieldDefinitionType.BOOLEAN]: (value) => Joi.boolean().strict().validate(value),
-  [CustomFieldDefinitionType.DATE]: (value) => Joi.date().validate(value),
-  [CustomFieldDefinitionType.DATETIME]: (value) => Joi.date().validate(value),
-  [CustomFieldDefinitionType.IMAGE]: (value) => Joi.array().min(1).unique()
-    .items(Joi.string().uri())
-    .validate(value),
-  [CustomFieldDefinitionType.FILE]: (value) => Joi.array().min(1).unique().items(Joi.object({
-    name: Joi.string().required(),
-    type: Joi.string(),
-    size: Joi.string(),
-    addedBy: Joi.string().uuid(),
-  }))
-    .validate(value),
-};

package/src/utils/validations/validators/select.validator.ts

@@ -1,12 +0,0 @@
-import Joi from 'joi';
-import type { Validator } from '../type';
-
-/**
- * Validate that the value is one of the select values
- */
-export const validateSelect: Validator<string, string[]> = (
-  value,
-  selectValues,
-) => (
-  Joi.string().allow(null).valid(...selectValues).validate(value)
-);

package/src/utils/validations/validators/status.validator.ts

@@ -1,22 +0,0 @@
-import Joi from 'joi';
-import type { Validator } from '../type';
-
-type StatusColor = string | null; // TODO: Takes from @autofleet/colors ?
-type StatusValue = string;
-type StatusOption = {
-  value: StatusValue;
-  color: StatusColor;
-}
-
-/**
-* Validate that the value is one of the status values
-*/
-export const validateStatus: Validator<StatusValue, StatusOption[]> = (
-  value,
-  statusValues,
-) => (
-  Joi.string()
-    .allow(null)
-    .valid(...statusValues.map((statusValue) => statusValue.value))
-    .validate(value)
-);

package/tsconfig.build.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": [
-    "src/**/*",
-  ],
-  "exclude": ["node_modules", "src/tests/**", "**/*.test.ts"]
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "commonjs",
-    "declaration": true,
-    "outDir": "./dist",
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "allowJs": true
-  },
-  "include": [
-    "src/**/*",
-  ],
-  "exclude": ["node_modules"]
-}