@autofleet/sadot 0.12.0 → 0.13.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.12.0",
+  "version": "0.13.0-beta.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -29,6 +29,8 @@
   "dependencies": {
     "@autofleet/common-types": "^4.4.0",
     "@autofleet/events": "^4.0.0",
+    "ajv": "^8.12.0",
+    "http-status-codes": "^2.3.0",
     "joi": "^17.7.0",
     "pg": "^8.10.0",
     "reflect-metadata": "^0.1.13",

package/src/api/v1/index.ts

@@ -1,9 +1,11 @@
 import { Router } from '@autofleet/node-common';
 import logger from '../../utils/logger';
 import definitionRouter from './definition';
+import validatorRouter from './validator';
 
 const router = Router({ logger });
 
 router.use('/custom-field-definitions/:modelName', definitionRouter);
+router.use('/custom-validators/:modelName', validatorRouter);
 
 export default router;

package/src/api/v1/validator/index.ts

@@ -0,0 +1,127 @@
+import { ResourceNotFoundError } from '@autofleet/errors';
+import { Router } from '@autofleet/node-common';
+import { StatusCodes } from 'http-status-codes';
+import handleError from '../errors';
+import * as ValidatorRepo from '../../../repository/validator';
+import validations from './validations';
+import logger from '../../../utils/logger';
+import { validateValidatorSchema } from '../../../utils/validations/schema/validator-schema';
+import type { CustomValidator } from '../../../models';
+
+const router = Router({ logger });
+const ENTITY = 'CustomValidator';
+
+/**
+ * Create
+ */
+router.post<{ modelName: string }>('/', async (req, res) => {
+  const { modelName } = req.params;
+  try {
+    // Validate the request body
+    const validatedPayload = await validations.create.validateAsync(req.body);
+
+    // Validate that the schema is a valid AJV schema
+    validateValidatorSchema(validatedPayload.schema);
+
+    const validator = await ValidatorRepo.create({
+      ...validatedPayload,
+      modelType: modelName,
+    });
+
+    return res.status(StatusCodes.CREATED).json(validator);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in create ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get all
+ */
+router.get<
+  { modelName: string },
+  CustomValidator[],
+  never,
+  { entityId?: string; entityType?: string }
+>('/', async (req, res) => {
+  try {
+    const { modelName } = req.params;
+    const { entityId, entityType } = req.query;
+
+    const where = {
+      modelType: modelName,
+      ...(entityId && { entityId }),
+      ...(entityType && { entityType }),
+    };
+
+    const validators = await ValidatorRepo.findAll(where);
+
+    return res.status(StatusCodes.OK).json(validators);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in get all ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get by id
+ */
+router.get<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId } = req.params;
+    const validators = await ValidatorRepo.findAll({ id: validatorId });
+
+    if (!validators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    return res.status(StatusCodes.OK).json(validators[0]);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in get ${ENTITY} request` });
+  }
+});
+
+/**
+ * Update
+ */
+router.patch<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId } = req.params;
+
+    // Validate the request body
+    const validatedPayload = await validations.update.validateAsync(req.body);
+
+    // If schema is included in the update, validate that it's a valid AJV schema
+    if (validatedPayload.schema) {
+      validateValidatorSchema(validatedPayload.schema);
+    }
+
+    const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
+
+    if (!count) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    return res.status(StatusCodes.OK).json(validators[0]);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in update ${ENTITY} request` });
+  }
+});
+
+/**
+ * Delete (disable)
+ */
+router.delete<{ modelName: string; validatorId: string }>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId } = req.params;
+    const [count] = await ValidatorRepo.disable(validatorId);
+
+    if (!count) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    return res.status(StatusCodes.NO_CONTENT).send();
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in delete ${ENTITY} request` });
+  }
+});
+
+export default router;

package/src/api/v1/validator/validations.ts

@@ -0,0 +1,39 @@
+import Joi from 'joi';
+
+// Schema for validating JSON Schema objects
+const jsonSchemaValidation = Joi.object().unknown(true);
+
+const validationSchemas = {
+  create: Joi.object({
+    entityId: Joi.string().uuid().required(),
+    entityType: Joi.string().required(),
+    schema: Joi.object({
+      type: Joi.string().valid('object').required(),
+      properties: Joi.object({
+        before: jsonSchemaValidation,
+        after: jsonSchemaValidation,
+      }).required(),
+      if: Joi.object().optional(),
+      then: Joi.object().optional(),
+      else: Joi.object().optional(),
+    }).required(),
+  }),
+
+  update: Joi.object({
+    entityId: Joi.string().uuid(),
+    entityType: Joi.string(),
+    schema: Joi.object({
+      type: Joi.string().valid('object'),
+      properties: Joi.object({
+        before: jsonSchemaValidation,
+        after: jsonSchemaValidation,
+      }),
+      if: Joi.object().optional(),
+      then: Joi.object().optional(),
+      else: Joi.object().optional(),
+    }),
+    disabled: Joi.boolean(),
+  }).min(1),
+};
+
+export default validationSchemas;

package/src/events/index.ts

@@ -47,7 +47,7 @@ export const sendDimEvent = (instance): void => {
     mapping.tableName,
     mapping.eventVersion,
     objectToSend,
-  ).catch(() => null);
+  ).catch(() => {});
 };
 
 export default events;

package/src/hooks/hooks.ts

@@ -0,0 +1,304 @@
+import type { WhereOptions } from 'sequelize';
+import Ajv from 'ajv';
+import { BadRequest } from '@autofleet/errors';
+import logger from '../utils/logger';
+import * as ValidatorRepo from '../repository/validator';
+import * as DefinitionRepo from '../repository/definition';
+import { MissingRequiredCustomFieldError } from '../errors';
+import type { CustomFieldOptions, ModelOptions } from '../types';
+import applyScopeToInstance from '../utils/scopeAttributes';
+import updateInstanceValues from './utils/updateInstanceValues';
+
+// Initialize Ajv with relaxed settings to avoid warnings
+const ajv = new Ajv({
+  allErrors: true,
+  strict: false, // Disable strict mode to avoid warnings
+  strictTypes: false, // Disable strict type checking
+});
+
+/**
+ * Validates the model using custom validators
+ */
+const validateModel = async (
+  instance,
+  options,
+  scopeAttributes: string[],
+  isCreate = false,
+): Promise<void> => {
+  const modelType = instance.constructor.name;
+
+  logger.debug('sadot - validating model', { isCreate, modelType });
+  const identifiers = applyScopeToInstance(instance, scopeAttributes);
+
+  logger.debug('sadot - identifiers', { identifiers });
+
+  // Skip if no identifiers
+  if (!identifiers || Object.keys(identifiers).length === 0) {
+    logger.debug('sadot - skipping validation: no identifiers');
+    return;
+  }
+
+  // Find the entityId from identifiers (fleetId, businessModelId, etc.)
+  const entityId = Object.values(identifiers)[0]; // Get the first value as entityId
+
+  logger.debug('sadot - entityId', { entityId });
+
+  if (!entityId) {
+    logger.debug('sadot - skipping validation: no entityId');
+    return;
+  }
+
+  const validators = await ValidatorRepo.findAllByModelType(
+    modelType,
+    entityId,
+    { transaction: options.transaction },
+  );
+
+  logger.debug('sadot - validators found', { count: validators.length });
+
+  if (!validators.length) {
+    logger.debug('sadot - skipping validation: no validators found');
+    return;
+  }
+
+  // For updates, get the previous values
+  const originalValues = isCreate
+    ? null
+    : {
+      ...instance.previous(),
+      customFields: instance.previous('customFields') || {},
+    };
+
+  // For debugging in case of update
+  if (!isCreate) {
+    logger.debug('sadot - validate with values', {
+      before: originalValues,
+      after: {
+        ...instance.dataValues,
+        ...instance.customFields,
+      },
+      schema: JSON.stringify(validators[0].schema),
+    });
+  }
+
+  // eslint-disable-next-line no-restricted-syntax
+  for (const validator of validators) {
+    const { schema } = validator;
+    const typedSchema = schema as Record<string, any>;
+
+    logger.debug('sadot - validating with schema', {
+      schema: JSON.stringify(schema),
+      hasAfterProps: !!typedSchema.properties?.after,
+      hasBeforeProps: !!typedSchema.properties?.before,
+    });
+
+    if (isCreate) {
+      // For create operations, we only need the 'after' state
+      if (typedSchema.properties?.after) {
+        const validateSchema = ajv.compile({
+          ...schema,
+          // Focus only on the 'after' validation part for create
+          properties: {
+            after: typedSchema.properties.after,
+          },
+        });
+
+        const isValid = validateSchema({
+          after: {
+            ...instance.dataValues,
+            ...instance.customFields,
+          },
+        });
+
+        if (!isValid) {
+          const errorDetails = validateSchema.errors?.map((err) =>
+            `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
+
+          throw new BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], [`Validation failed for ${modelType}`]);
+        }
+      } else if (!typedSchema.properties?.before && !typedSchema.properties?.after) {
+        // If no before/after properties are defined, validate the entire schema against the model
+        const validateSchema = ajv.compile(schema);
+
+        const isValid = validateSchema({
+          ...instance.dataValues,
+          ...instance.customFields,
+        });
+
+        if (!isValid) {
+          const errorDetails = validateSchema.errors?.map((err) =>
+            `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
+
+          throw new BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], [`Validation failed for ${modelType}`]);
+        }
+      }
+    } else {
+      // For update operations, we need both before and after
+      const validateSchema = ajv.compile(typedSchema);
+
+      const isValid = validateSchema({
+        before: originalValues,
+        after: {
+          ...instance.dataValues,
+          ...instance.customFields,
+        },
+      });
+
+      if (!isValid) {
+        const errorDetails = validateSchema.errors?.map((err) =>
+          `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
+
+        throw new BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], [`Validation failed for ${modelType}`]);
+      }
+    }
+  }
+};
+
+/**
+ * Hook to handle validation and custom fields during creation
+ */
+export const beforeCreate = (
+  scopeAttributes: string[],
+  modelOptions: ModelOptions = {},
+  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
+) => async (
+  instance,
+  options,
+): Promise<void> => {
+  logger.debug('sadot - before create hook');
+  const { fields } = options;
+  const { include, useEntityIdFromInclude } = modelOptions;
+  const modelType = instance.constructor.name;
+
+  const identifiers = applyScopeToInstance(instance, scopeAttributes);
+
+  // Step 1: Handle custom fields default values and required fields
+  const where: WhereOptions = {
+    modelType,
+    disabled: false,
+    ...(!useEntityIdFromInclude && { entityId: identifiers }),
+  };
+
+  const fieldDefinitions = await DefinitionRepo.findAll(where, {
+    withDisabled: false,
+    transaction: options.transaction,
+    include: include?.(identifiers),
+  });
+
+  const requiredFieldsNames = Array.from(
+    new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)),
+  );
+
+  // Apply default values
+  const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
+  if (fieldsWithDefaultValue.length) {
+    // eslint-disable-next-line no-param-reassign
+    instance.customFields ||= {};
+    fieldsWithDefaultValue
+      .filter((def) => (instance.customFields?.[def.name] === undefined))
+      .forEach(({ name, defaultValue }) => {
+        // eslint-disable-next-line no-param-reassign
+        instance.customFields[name] = defaultValue;
+      });
+  }
+
+  // Check for required fields
+  const { customFields } = instance;
+  const fieldsNames = Object.keys(customFields ?? {});
+  const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+  if (missingFields?.length) {
+    throw new MissingRequiredCustomFieldError(missingFields);
+  }
+
+  // Step 2: Validate the model data (including custom fields)
+  await validateModel(instance, options, scopeAttributes, true);
+
+  // Step 3: Save custom field values if they exist
+  const customFieldsIdx = fields.indexOf('customFields');
+  if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
+    // No custom fields to update
+    return;
+  }
+
+  // Save custom field values
+  await updateInstanceValues({
+    modelId: instance.id,
+    modelType,
+    identifiers,
+    customFields,
+    options: {
+      useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+      transaction: options.transaction,
+      modelOptions,
+    },
+  });
+
+  // Remove customFields from fields array after handling
+  // eslint-disable-next-line no-param-reassign
+  fields.splice(customFieldsIdx, 1);
+};
+
+/**
+ * Hook to handle validation and custom fields during update
+ */
+export const beforeUpdate = (
+  scopeAttributes: string[],
+  modelOptions: ModelOptions = {},
+  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
+) => async (
+  instance,
+  options,
+): Promise<void> => {
+  logger.debug('sadot - before update hook');
+  const { fields } = options;
+  const modelType = instance.constructor.name;
+  const identifiers = applyScopeToInstance(instance, scopeAttributes);
+
+  // Step 1: Validate the model data (including custom fields)
+  await validateModel(instance, options, scopeAttributes, false);
+
+  // Step 2: Update custom field values if they exist
+  const customFieldsIdx = fields.indexOf('customFields');
+  if (customFieldsIdx > -1) {
+    const { customFields } = instance;
+
+    if (!Object.keys(customFields).length) {
+      return;
+    }
+
+    // Save custom field values
+    await updateInstanceValues({
+      modelId: instance.id,
+      modelType,
+      identifiers,
+      customFields,
+      options: {
+        useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+        transaction: options.transaction,
+        modelOptions,
+      },
+    });
+
+    // Remove customFields from fields array after handling
+    // eslint-disable-next-line no-param-reassign
+    fields.splice(customFieldsIdx, 1);
+  }
+};
+
+/**
+ * Hook to enable individual hooks for bulk create operations
+ */
+export const beforeBulkCreate = (options): void => {
+  // This will activate the beforeCreate hook on each instance
+  // eslint-disable-next-line no-param-reassign
+  options.individualHooks = true;
+};
+
+/**
+ * Hook to enable individual hooks for bulk update operations
+ */
+export const beforeBulkUpdate = (options): void => {
+  // This will activate the beforeUpdate hook on each instance
+  // eslint-disable-next-line no-param-reassign
+  options.individualHooks = true;
+};

package/src/hooks/index.ts

@@ -1,15 +1,20 @@
 import enrichResults from './enrich';
 import { beforeFind } from './find';
-import { beforeBulkUpdate, beforeUpdate } from './update';
-import { beforeBulkCreate, beforeCreate } from './create';
 import workaround from './workaround';
+import {
+  beforeCreate,
+  beforeUpdate,
+  beforeBulkCreate,
+  beforeBulkUpdate,
+} from './hooks';
 
+// Export the hooks
 export {
   enrichResults,
   beforeFind,
-  beforeBulkUpdate,
+  workaround,
+  beforeCreate,
   beforeUpdate,
   beforeBulkCreate,
-  beforeCreate,
-  workaround,
+  beforeBulkUpdate,
 };

package/src/index.ts

@@ -17,6 +17,11 @@ export * from './utils/constants';
 
 export * from './utils/helpers';
 
+// Export repositories
+export * as DefinitionRepo from './repository/definition';
+export * as ValueRepo from './repository/value';
+export * as ValidatorRepo from './repository/validator';
+
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
  * @see {@link 'custom-fields/config'} for configurations
@@ -40,6 +45,7 @@ const useCustomFields = async (
   await initTables(sequelize, options.getUser, { useCustomFieldsEntries });
   addScopes(models, getModel, { useCustomFieldsEntries });
   applyCustomAssociation(models);
+
   logger.debug('sadot - custom fields finished initializing with models', models);
   return sequelize;
 };

package/src/models/CustomValidator.ts

@@ -0,0 +1,76 @@
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  Default,
+  AfterUpsert,
+} from 'sequelize-typescript';
+import { randomUUID } from 'node:crypto';
+import { sendDimEvent } from '../events';
+
+@Table({
+  timestamps: true,
+})
+class CustomValidator extends Model {
+  @PrimaryKey
+  @Default(() => randomUUID())
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    id!: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    /** The ID of the entity for which this validator is defined, e.g. fleetId / etc. */
+    entityId!: string;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    /** The type of entity (fleet, businessModel, etc). */
+    entityType!: string;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    /** The type of model this validator applies to. e.g. Vehicle / StopPoint / etc. */
+    modelType!: string;
+
+  @Column({
+    type: DataType.JSONB,
+    allowNull: false,
+  })
+    /** JSON Schema to validate models against */
+    schema!: Record<string, unknown>;
+
+  @Column({
+    type: DataType.BOOLEAN,
+    allowNull: false,
+    defaultValue: false,
+  })
+    disabled!: boolean;
+
+  @Column
+    createdAt?: Date;
+
+  @Column
+    updatedAt?: Date;
+
+  @AfterUpsert
+  static afterSaveHandler(instance: CustomValidator, options): void {
+    if (options.transaction) {
+      options.transaction.afterCommit(() => sendDimEvent(instance));
+    } else {
+      sendDimEvent(instance);
+    }
+  }
+}
+
+export default CustomValidator;

package/src/models/index.ts

@@ -10,15 +10,16 @@ import ContextTestModel from './tests/contextAwareModels/ContextTestModel';
 import AssociatedTestModel from './tests/AssociatedTestModel';
 import type { CustomFieldOptions } from '../types';
 import CustomFieldEntries from './CustomFieldEntries';
+import CustomValidator from './CustomValidator';
 
-type ProductionModel = typeof CustomFieldDefinition | typeof CustomFieldValue | typeof CustomFieldEntries
+type ProductionModel = typeof CustomFieldDefinition | typeof CustomFieldValue | typeof CustomFieldEntries | typeof CustomValidator
 interface InitTablesOptions {
   schemaPrefix?: string
   schemaVersion?: string
   useCustomFieldsEntries?: boolean
 }
 
-const productionModels: ProductionModel[] = [CustomFieldDefinition, CustomFieldValue];
+const productionModels: ProductionModel[] = [CustomFieldDefinition, CustomFieldValue, CustomValidator];
 const testModels = [TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel];
 
 const SADOT_MIGRATION_PREFIX = 'sadot-migration';
@@ -99,6 +100,9 @@ const initTables = async (
       await CustomFieldEntries.sync({ alter: true });
     }
 
+    // Always sync CustomValidator
+    await CustomValidator.sync({ alter: true });
+
     if (expectedSchemaVersionIndex === -1) {
       await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
     }
@@ -136,6 +140,7 @@ export {
   CustomFieldValue,
   CustomFieldDefinition,
   CustomFieldEntries,
+  CustomValidator,
   TestModel,
   AssociatedTestModel,
   ContextAwareTestModel,