@autofleet/sadot 0.6.1-temp-2 → 0.6.1

package/dist/utils/init.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCustomAssociation = exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
+const sequelize_1 = require("sequelize");
+const common_types_1 = require("@autofleet/common-types");
+const models_1 = require("../models");
+const hooks_1 = require("../hooks");
+const scopes_1 = require("../scopes");
+const logger_1 = __importDefault(require("./logger"));
+const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
+const addHooks = (models, getModel) => {
+    models.forEach(async ({ name, scopeAttributes, modelOptions, }) => {
+        try {
+            const model = getModel(name);
+            if (!model) {
+                logger_1.default.warn('sadot - tried to addHooks to a model that does not exist yet', {
+                    name,
+                    scopeAttributes,
+                });
+                return;
+            }
+            model.rawAttributes.customFields = {
+                type: sequelize_1.DataTypes.VIRTUAL,
+            };
+            model.refreshAttributes();
+            // TODO: Uncomment after tests are passed
+            // model.addHook('afterFind', workaround);
+            model.addHook('beforeFind', 'sadot-beforeFind', (0, hooks_1.beforeFind)(scopeAttributes));
+            model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', hooks_1.beforeBulkCreate);
+            model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', hooks_1.beforeBulkUpdate);
+            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes, modelOptions));
+            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes, modelOptions));
+            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes, 'afterFind', modelOptions));
+            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
+            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
+        }
+    });
+};
+exports.addHooks = addHooks;
+const removeHooks = (models, getModel) => {
+    models.forEach(async ({ name }) => {
+        try {
+            const model = getModel(name);
+            if (!model)
+                return;
+            if (model.rawAttributes.customFields) {
+                delete model.rawAttributes.customFields;
+                model.refreshAttributes();
+            }
+            // model.removeHook('afterFind', 'sadot-workaround');
+            model.removeHook('beforeFind', 'sadot-beforeFind');
+            model.removeHook('beforeBulkCreate', 'sadot-beforeBulkCreate');
+            model.removeHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate');
+            model.removeHook('beforeCreate', 'sadot-beforeCreate');
+            model.removeHook('beforeUpdate', 'sadot-beforeUpdate');
+            model.removeHook('afterFind', 'sadot-afterFind');
+            model.removeHook('afterUpdate', 'sadot-afterUpdate');
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
+        }
+    });
+};
+exports.removeHooks = removeHooks;
+/**
+ *  Necessary associations for the {@link customFieldsFilterScope} scope
+ */
+const addAssociations = (model, modelName) => {
+    model.hasMany(models_1.CustomFieldValue, { foreignKey: 'modelId', as: 'customFieldValue' });
+    // TBC: maybe can be removed
+    models_1.CustomFieldValue.belongsTo(model, { foreignKey: 'modelId', as: modelName });
+};
+const addScopes = (models, getModel) => {
+    models.forEach(async ({ name, scopeAttributes }) => {
+        try {
+            const model = getModel(name);
+            if (!model) {
+                logger_1.default.warn('sadot - tried to addScopes to a model that does not exist yet', {
+                    name,
+                    scopeAttributes,
+                });
+                return;
+            }
+            // Necessary associations for the filtering scope
+            addAssociations(model, name);
+            // Add filter scope
+            model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, (0, scopes_1.customFieldsFilterScope)(name));
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields scopes to model ${name}. `, e);
+        }
+    });
+};
+exports.addScopes = addScopes;
+const applyCustomAssociation = (models) => {
+    models.forEach(({ modelOptions }) => {
+        modelOptions?.customAssociation?.(models_1.CustomFieldDefinition);
+    });
+};
+exports.applyCustomAssociation = applyCustomAssociation;

package/dist/utils/logger/index.d.ts

@@ -0,0 +1,2 @@
+declare const logger: any;
+export default logger;

package/dist/utils/logger/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Logger = require('@autofleet/logger');
+const logger = Logger();
+exports.default = logger;

package/dist/utils/scopeAttributes.d.ts

@@ -0,0 +1,2 @@
+declare const applyScopeToInstance: (instance: any, scopeAttributes: string[]) => any[];
+export default applyScopeToInstance;

package/dist/utils/scopeAttributes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapAttributeToInstance = (scopeAttributes, instance) => scopeAttributes.map((attr) => instance[attr]);
+const applyScopeToInstance = (instance, scopeAttributes) => {
+    const uniqueAttributes = Array.from(new Set(scopeAttributes));
+    if (Array.isArray(instance)) {
+        return instance.flatMap((ins) => mapAttributeToInstance(uniqueAttributes, ins));
+    }
+    return mapAttributeToInstance(uniqueAttributes, instance);
+};
+exports.default = applyScopeToInstance;

package/dist/utils/validations/custom-fields.d.ts

@@ -0,0 +1,3 @@
+import Joi from 'joi';
+declare const CustomFieldsSchema: Joi.ObjectSchema<any>;
+export { CustomFieldsSchema };

package/dist/utils/validations/custom-fields.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomFieldsSchema = void 0;
+/* eslint-disable import/prefer-default-export */
+const joi_1 = __importDefault(require("joi"));
+const CustomFieldsSchema = joi_1.default.object().pattern(joi_1.default.string(), joi_1.default.any());
+exports.CustomFieldsSchema = CustomFieldsSchema;

package/dist/utils/validations/custom.d.ts

@@ -0,0 +1,15 @@
+export declare const mustHaveCustomValidation: {
+    select: boolean;
+};
+/**
+ * Validates the given validations object against the supported field types and their validators.
+ * @return true if the validation is valid, false otherwise.
+ */
+export declare const validateValidation: (valueType: any, validation: any) => boolean;
+/**
+ * Validates the given value against the custom validation rules for the specified field type.
+ * If no custom validation rules are provided, it falls back to the default validation.
+ * @returns true if the value is valid according to the validation rules, false otherwise.
+ */
+declare const customValidation: (value: any, valueType: any, validation: any) => boolean;
+export default customValidation;

package/dist/utils/validations/custom.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateValidation = exports.mustHaveCustomValidation = void 0;
+/* eslint-disable no-shadow */
+const logger_1 = __importDefault(require("../logger"));
+const type_1 = require("./type");
+const validators_1 = __importDefault(require("./validators"));
+exports.mustHaveCustomValidation = {
+    [type_1.CustomFieldDefinitionType.SELECT]: true,
+};
+/**
+ * Validates the given validations object against the supported field types and their validators.
+ * @return true if the validation is valid, false otherwise.
+ */
+const validateValidation = (valueType, validation) => {
+    if (!validation) {
+        if (exports.mustHaveCustomValidation[valueType]) {
+            logger_1.default.error(`No custom validation for custom field type ${valueType} found`);
+            return false;
+        }
+        return true;
+    }
+    return true;
+};
+exports.validateValidation = validateValidation;
+/**
+ * Validates the given value against the custom validation rules for the specified field type.
+ * If no custom validation rules are provided, it falls back to the default validation.
+ * @returns true if the value is valid according to the validation rules, false otherwise.
+ */
+const customValidation = (value, valueType, validation) => {
+    const validator = validators_1.default?.[valueType];
+    if (!validation || !validator) {
+        return (0, exports.validateValidation)(valueType, validation);
+    }
+    // Always allow null values
+    return value === null || validator(value, validation);
+};
+exports.default = customValidation;

package/dist/utils/validations/index.d.ts

@@ -0,0 +1,2 @@
+declare const validateValue: (value: any, valueType: any, customValidations: any) => boolean;
+export default validateValue;

package/dist/utils/validations/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const custom_1 = __importDefault(require("./custom"));
+const type_1 = __importDefault(require("./type"));
+const validateValue = (value, valueType, customValidations) => {
+    if (!(0, type_1.default)(value, valueType)) {
+        return false;
+    }
+    if (customValidations) {
+        return (0, custom_1.default)(value, valueType, customValidations);
+    }
+    // if (validations.required && !value) {
+    //   return false;
+    // }
+    return true;
+};
+exports.default = validateValue;

package/dist/utils/validations/type.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Supported custom field types
+ */
+export declare enum CustomFieldDefinitionType {
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    DATE = "date",
+    DATETIME = "datetime",
+    TEXT = "text",
+    IMAGE = "image",
+    SELECT = "select"
+}
+/**
+ * Validate that the given value is really of type "valueType"
+ * TODO: verify that required field not set to null
+ */
+declare const validateValueType: (value: unknown, valueType: CustomFieldDefinitionType) => boolean;
+export default validateValueType;

package/dist/utils/validations/type.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.CustomFieldDefinitionType = void 0;
+const joi_1 = __importDefault(require("joi"));
+/**
+ * Supported custom field types
+ */
+// eslint-disable-next-line no-shadow
+var CustomFieldDefinitionType;
+(function (CustomFieldDefinitionType) {
+    CustomFieldDefinitionType["NUMBER"] = "number";
+    CustomFieldDefinitionType["BOOLEAN"] = "boolean";
+    CustomFieldDefinitionType["DATE"] = "date";
+    CustomFieldDefinitionType["DATETIME"] = "datetime";
+    CustomFieldDefinitionType["TEXT"] = "text";
+    CustomFieldDefinitionType["IMAGE"] = "image";
+    CustomFieldDefinitionType["SELECT"] = "select";
+})(CustomFieldDefinitionType = exports.CustomFieldDefinitionType || (exports.CustomFieldDefinitionType = {}));
+/**
+ * Validate that the given value is really of type "valueType"
+ * TODO: verify that required field not set to null
+ */
+const validateValueType = (value, valueType) => {
+    if (value === null) {
+        // Null is always allowed
+        return true;
+    }
+    switch (valueType) {
+        case CustomFieldDefinitionType.TEXT:
+            return typeof value === 'string';
+        case CustomFieldDefinitionType.NUMBER:
+            return typeof value === 'number';
+        case CustomFieldDefinitionType.BOOLEAN:
+            return typeof value === 'boolean';
+        case CustomFieldDefinitionType.DATE:
+        case CustomFieldDefinitionType.DATETIME:
+            return !joi_1.default.date().validate(value).error;
+        case CustomFieldDefinitionType.SELECT:
+            return true; // custom validation
+        case CustomFieldDefinitionType.IMAGE:
+            return !joi_1.default.array().min(1).unique().items(joi_1.default.string().uri())
+                .validate(value).error;
+        default:
+            return false;
+    }
+};
+exports.default = validateValueType;

package/dist/utils/validations/validators.d.ts

@@ -0,0 +1,12 @@
+export declare enum CustomValidations {
+    SELECT = "select",
+    RANGE = "between"
+}
+type Validator = (value: any, validation: any) => boolean;
+/**
+ * Validators for custom fields
+ */
+declare const validators: {
+    [key: string]: Validator;
+};
+export default validators;

package/dist/utils/validations/validators.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomValidations = void 0;
+// eslint-disable-next-line no-shadow
+var CustomValidations;
+(function (CustomValidations) {
+    CustomValidations["SELECT"] = "select";
+    CustomValidations["RANGE"] = "between";
+})(CustomValidations = exports.CustomValidations || (exports.CustomValidations = {}));
+/**
+ * Validate {@link CustomValidations.ENUM Enum}
+ */
+const validateEnum = (value, enumValues) => (Array.isArray(enumValues)
+    && enumValues.length > 0
+    && enumValues.includes(value));
+/**
+ * Validate {@link CustomValidations.RANGE Range}
+ */
+const validateRange = (value, range) => {
+    const [min, max] = range;
+    if (min === undefined || max === undefined) {
+        return false;
+    }
+    return value >= range.min && value <= range.max;
+};
+/**
+ * Validators for custom fields
+ */
+const validators = {
+    [CustomValidations.SELECT]: validateEnum,
+    [CustomValidations.RANGE]: validateRange,
+};
+exports.default = validators;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.6.1-temp-2",
+  "version": "0.6.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -59,4 +59,4 @@
   },
   "author": "Autofleet",
   "license": "ISC"
-}
+}

package/src/utils/validations/type.ts

@@ -11,7 +11,6 @@ export enum CustomFieldDefinitionType {
   TEXT = 'text',
   IMAGE = 'image',
   SELECT = 'select',
-  FILE = 'file',
 }
 /**
  * Validate that the given value is really of type "valueType"
@@ -38,15 +37,6 @@ const validateValueType = (value: unknown, valueType: CustomFieldDefinitionType)
     case CustomFieldDefinitionType.IMAGE:
       return !Joi.array().min(1).unique().items(Joi.string().uri())
         .validate(value).error;
-    case CustomFieldDefinitionType.FILE:
-      return !Joi.array().min(1).unique().items(Joi.object({
-        id: Joi.string().uuid().required(),
-        name: Joi.string().required(),
-        link: Joi.string().required(),
-        createdAt: Joi.date(),
-        addedBy: Joi.string().uuid(),
-      }))
-        .validate(value).error;
     default:
       return false;
   }