@autofleet/sadot 0.13.0-beta.0 → 0.13.0-beta.10

package/dist/api/index.d.ts

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

package/dist/api/index.js

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

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

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

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

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

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

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

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

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

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

package/dist/api/v1/index.js

@@ -0,0 +1,13 @@
+"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 validator_1 = __importDefault(require("./validator"));
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
+router.use('/custom-field-definitions/:modelName', definition_1.default);
+router.use('/custom-validators/:modelName', validator_1.default);
+exports.default = router;

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

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

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

@@ -0,0 +1,132 @@
+"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 http_status_codes_1 = require("http-status-codes");
+const errors_2 = __importDefault(require("../errors"));
+const ValidatorRepo = __importStar(require("../../../repository/validator"));
+const validations_1 = __importDefault(require("./validations"));
+const logger_1 = __importDefault(require("../../../utils/logger"));
+const validator_schema_1 = require("../../../utils/validations/schema/validator-schema");
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
+const ENTITY = 'CustomValidator';
+/**
+ * Create
+ */
+router.post('/', async (req, res) => {
+    const { modelName } = req.params;
+    try {
+        // Validate the request body
+        const validatedPayload = await validations_1.default.create.validateAsync(req.body);
+        // Validate that the schema is a valid AJV schema
+        (0, validator_schema_1.validateValidatorSchema)(validatedPayload.schema);
+        const validator = await ValidatorRepo.create({
+            ...validatedPayload,
+            modelType: modelName,
+        });
+        return res.status(http_status_codes_1.StatusCodes.CREATED).json(validator);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in create ${ENTITY} request` });
+    }
+});
+/**
+ * Get all
+ */
+router.get('/', 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(http_status_codes_1.StatusCodes.OK).json({ validators });
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get all ${ENTITY} request` });
+    }
+});
+/**
+ * Get by id
+ */
+router.get('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId } = req.params;
+        const validators = await ValidatorRepo.findAll({ id: validatorId });
+        if (!validators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        return res.status(http_status_codes_1.StatusCodes.OK).json(validators[0]);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get ${ENTITY} request` });
+    }
+});
+/**
+ * Update
+ */
+router.patch('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId } = req.params;
+        // Validate the request body
+        const validatedPayload = await validations_1.default.update.validateAsync(req.body);
+        // If schema is included in the update, validate that it's a valid AJV schema
+        if (validatedPayload.schema) {
+            (0, validator_schema_1.validateValidatorSchema)(validatedPayload.schema);
+        }
+        const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
+        if (!count) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        return res.status(http_status_codes_1.StatusCodes.OK).json(validators[0]);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in update ${ENTITY} request` });
+    }
+});
+/**
+ * Delete (disable)
+ */
+router.delete('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId } = req.params;
+        const [count] = await ValidatorRepo.disable(validatorId);
+        if (!count) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        return res.status(http_status_codes_1.StatusCodes.NO_CONTENT).send();
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in delete ${ENTITY} request` });
+    }
+});
+exports.default = router;

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

@@ -0,0 +1,6 @@
+import Joi from 'joi';
+declare const validationSchemas: {
+    create: Joi.ObjectSchema<any>;
+    update: Joi.ObjectSchema<any>;
+};
+export default validationSchemas;

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

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const joi_1 = __importDefault(require("joi"));
+// Schema for validating JSON Schema objects
+const jsonSchemaValidation = joi_1.default.object().unknown(true);
+const validationSchemas = {
+    create: joi_1.default.object({
+        entityId: joi_1.default.string().uuid().required(),
+        entityType: joi_1.default.string().required(),
+        schema: joi_1.default.object({
+            type: joi_1.default.string().valid('object').required(),
+            properties: joi_1.default.object({
+                before: jsonSchemaValidation,
+                after: jsonSchemaValidation,
+            }).required(),
+            if: joi_1.default.object().optional(),
+            then: joi_1.default.object().optional(),
+            else: joi_1.default.object().optional(),
+        }).required(),
+    }),
+    update: joi_1.default.object({
+        entityId: joi_1.default.string().uuid(),
+        schema: joi_1.default.object({
+            type: joi_1.default.string().valid('object'),
+            properties: joi_1.default.object({
+                before: jsonSchemaValidation,
+                after: jsonSchemaValidation,
+            }),
+            if: joi_1.default.object().optional(),
+            then: joi_1.default.object().optional(),
+            else: joi_1.default.object().optional(),
+        }),
+        disabled: joi_1.default.boolean(),
+    }).min(1),
+};
+exports.default = validationSchemas;

package/dist/errors/index.d.ts

@@ -0,0 +1,24 @@
+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[]);
+}

package/dist/errors/index.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingDefinitionError = exports.InvalidEntriesError = exports.InvalidValueError = exports.InvalidFieldTypeError = exports.UnsupportedCustomValidationError = exports.UnsupportedCustomFieldTypeError = exports.MissingRequiredCustomFieldError = void 0;
+/* eslint-disable max-classes-per-file */
+const errors_1 = require("@autofleet/errors");
+class MissingRequiredCustomFieldError extends errors_1.BadRequest {
+    constructor(missingFields) {
+        const err = new Error(`The following custom fields are required: ${missingFields.join(',')}`);
+        super([err], null, missingFields);
+        this.message = 'MISSING_REQUIRED_CUSTOM_FIELDS';
+    }
+}
+exports.MissingRequiredCustomFieldError = MissingRequiredCustomFieldError;
+class UnsupportedCustomFieldTypeError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Type "${fieldType}" is not supported`);
+        super([err], null, null);
+        this.message = 'UNSUPPORTED_CUSTOM_FIELD_TYPE';
+    }
+}
+exports.UnsupportedCustomFieldTypeError = UnsupportedCustomFieldTypeError;
+class UnsupportedCustomValidationError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Validation for "${fieldType}" is not supported`);
+        super([err], null, null);
+        this.message = 'UNSUPPORTED_CUSTOM_VALIDATION_TYPE';
+    }
+}
+exports.UnsupportedCustomValidationError = UnsupportedCustomValidationError;
+class InvalidFieldTypeError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Invalid field type ${fieldType}`);
+        super([err], null, null);
+        this.message = 'INVALID_FIELD_TYPE';
+    }
+}
+exports.InvalidFieldTypeError = InvalidFieldTypeError;
+class InvalidValueError extends errors_1.BadRequest {
+    constructor(value, fieldDefinitionName, joiValidationError) {
+        const formattedErrorMessage = joiValidationError.message
+            .replace(/"/g, '')
+            .replace('value', `'${fieldDefinitionName}'`);
+        const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
+        const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
+        const err = new Error(invalidValueMessage);
+        super([err], null, null);
+        this.message = invalidValueMessage;
+    }
+}
+exports.InvalidValueError = InvalidValueError;
+class InvalidEntriesError extends errors_1.BadRequest {
+    constructor(modelId, validationErrors) {
+        const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
+        super(errors, null, null);
+        this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (`${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`)).join('\n')}`;
+    }
+}
+exports.InvalidEntriesError = InvalidEntriesError;
+class MissingDefinitionError extends errors_1.BadRequest {
+    constructor(fieldNames) {
+        const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);
+        super([err], null, null);
+        this.message = 'MISSING_DEFINITION';
+    }
+}
+exports.MissingDefinitionError = MissingDefinitionError;

package/dist/events/index.d.ts

@@ -0,0 +1,4 @@
+import Events from '@autofleet/events';
+declare const events: Events;
+export declare const sendDimEvent: (instance: any) => void;
+export default events;

package/dist/events/index.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendDimEvent = void 0;
+const events_1 = __importDefault(require("@autofleet/events"));
+const logger_1 = __importDefault(require("../utils/logger"));
+const events = new events_1.default({ logger: logger_1.default });
+const KEYS_TO_CONVERT = ['value', 'defaultValue', 'blockEditingFromUI'];
+const stringifyBooleans = (savedObject, keysToConvert) => {
+    const savedObjectKeySet = new Set(Object.keys(savedObject));
+    if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) {
+        return savedObject;
+    }
+    return {
+        ...savedObject,
+        ...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === 'boolean' ? savedObject[key].toString() : savedObject[key]])),
+    };
+};
+const modelTableMapping = {
+    CustomFieldDefinition: {
+        tableName: 'dim_custom_field_definition',
+        eventVersion: '1',
+    },
+    CustomFieldValue: {
+        tableName: 'dim_custom_field_value',
+        eventVersion: '1',
+    },
+    CustomFieldEntries: {
+        tableName: 'dim_custom_field_entries',
+        eventVersion: '1',
+    },
+};
+const sendDimEvent = (instance) => {
+    const mapping = modelTableMapping[instance.constructor.name];
+    if (!mapping) {
+        return;
+    }
+    let objectToSend = instance.get();
+    try {
+        objectToSend = stringifyBooleans(instance.get(), KEYS_TO_CONVERT);
+    }
+    catch (err) {
+        logger_1.default.error('Failed to convert booleans in dim event payload', err);
+    }
+    events.sendObject(mapping.tableName, mapping.eventVersion, objectToSend).catch(() => { });
+};
+exports.sendDimEvent = sendDimEvent;
+exports.default = events;

package/dist/hooks/create.d.ts

@@ -0,0 +1,10 @@
+import type { CustomFieldOptions, ModelOptions } from '../types';
+/**
+ * A hook to create the custom fields when updating a model (more then one instance).
+ */
+export declare const beforeBulkCreate: (options: any) => void;
+/**
+ * A hook to create the custom fields when updating a model instance.
+ * TODO - cleanup if update fail
+ */
+export declare const beforeCreate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;