@autofleet/sadot 1.0.0-beta.0 → 1.0.0

package/src/utils/validations/index.ts

@@ -1,18 +1,18 @@
+import { InvalidEntriesError } from '../../errors';
+import type { CustomFieldDefinition } from '../../models';
+import type { CustomFieldEntriesDTO } from '../../types/entries';
 import type { CustomFieldDefinitionType } from '../constants';
 import { validators } from './validators';
 
+export const validateFieldType = (type: CustomFieldDefinitionType): boolean => Object.keys(validators).includes(type);
+
 export const validateValue = (
   value: unknown,
   valueType: CustomFieldDefinitionType,
   validation?: unknown,
 ) => {
   const validator = 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) {
@@ -20,3 +20,27 @@ export const validateValue = (
    * }
    */
 };
+
+export const validateInstanceCustomFieldEntries = (instance: CustomFieldEntriesDTO, definitionsByName: { [defName: string]: CustomFieldDefinition; }) => {
+  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 = validateValue(value, fieldType, validation);
+      if (result?.error) {
+        return {
+          joiValidationError: result.error,
+          fieldDefinitionName: customFieldName,
+          value,
+        };
+      }
+      return null;
+    })
+    .filter((result) => !!result);
+
+  if (validationErrors?.length) {
+    throw new InvalidEntriesError(instance.modelId, validationErrors);
+  }
+};

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,106 @@
+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,3 +1,4 @@
+import type { ValidationResult } from 'joi';
 import type { CustomFieldDefinitionType } from '../constants';
 
 /**
@@ -8,7 +9,7 @@ import type { CustomFieldDefinitionType } from '../constants';
 export type Validator<Value, DefinitionValidationObject> = (
    value: Value,
    validation?: DefinitionValidationObject
-  ) => boolean;
+  ) => ValidationResult;
 
 /**
  * Validators is a map of custom-field types to their respective validators.

package/src/utils/validations/validators/index.ts

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

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

@@ -1,3 +1,4 @@
+import Joi from 'joi';
 import type { Validator } from '../type';
 
 /**
@@ -6,6 +7,6 @@ import type { Validator } from '../type';
 export const validateSelect: Validator<string, string[]> = (
   value,
   selectValues,
-) => (Array.isArray(selectValues)
-      && selectValues.includes(value)
+) => (
+  Joi.string().allow(null).valid(...selectValues).validate(value)
 );

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

@@ -1,3 +1,4 @@
+import Joi from 'joi';
 import type { Validator } from '../type';
 
 type StatusColor = string | null; // TODO: Takes from @autofleet/colors ?
@@ -13,6 +14,9 @@ type StatusOption = {
 export const validateStatus: Validator<StatusValue, StatusOption[]> = (
   value,
   statusValues,
-) => (Array.isArray(statusValues)
-   && statusValues.some((status) => status.value === value)
+) => (
+  Joi.string()
+    .allow(null)
+    .valid(...statusValues.map((statusValue) => statusValue.value))
+    .validate(value)
 );

package/tsconfig.build.json

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

package/tsconfig.json

@@ -12,5 +12,5 @@
   "include": [
     "src/**/*",
   ],
-  "exclude": ["node_modules", "**/*.test.ts"]
+  "exclude": ["node_modules"]
 }