@autofleet/sadot 0.6.1-temp-2 → 0.6.1

package/dist/hooks/update.js

@@ -0,0 +1,59 @@
+"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 });
+exports.beforeUpdate = exports.beforeBulkUpdate = void 0;
+const logger_1 = __importDefault(require("../utils/logger"));
+const ValueRepo = __importStar(require("../repository/value"));
+const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+/**
+ * A hook to update the custom fields when updating a model (more then one instance).
+ */
+const beforeBulkUpdate = (options) => {
+    // This will activate the beforeUpdate hook on each updating instance.
+    // eslint-disable-next-line no-param-reassign
+    options.individualHooks = true;
+};
+exports.beforeBulkUpdate = beforeBulkUpdate;
+/**
+ * A hook to update the custom fields when updating a model instance.
+ * TODO - cleanup if update fail
+ */
+const beforeUpdate = (scopeAttributes, modelOptions = {}) => async (instance, options) => {
+    logger_1.default.debug('sadot - before update hook');
+    const { fields } = options;
+    const modelType = instance.constructor.name;
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
+    const customFieldsIdx = fields.indexOf('customFields');
+    if (customFieldsIdx > -1) {
+        const { customFields } = instance;
+        await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, { transaction: options.transaction, modelOptions });
+        // eslint-disable-next-line no-param-reassign
+        fields.splice(customFieldsIdx, 1);
+    }
+};
+exports.beforeUpdate = beforeUpdate;

package/dist/hooks/workaround.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Workaround to a bug in sequelize.🐛
+ *
+ * **afterFind hook** isn't working on nested (included) models.
+ * The solution here is to add a global afterFind hook,
+ * which manually calls the afterFind hook of each model, recursively
+ * https://github.com/sequelize/sequelize/issues/4627
+ */
+declare const handleChildrenAfterFindHook: (instances: any, options: any, level?: number) => any;
+export default handleChildrenAfterFindHook;

package/dist/hooks/workaround.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Workaround to a bug in sequelize.🐛
+ *
+ * **afterFind hook** isn't working on nested (included) models.
+ * The solution here is to add a global afterFind hook,
+ * which manually calls the afterFind hook of each model, recursively
+ * https://github.com/sequelize/sequelize/issues/4627
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const handleChildrenAfterFindHook = async (instances, options, level = 0) => {
+    if (!instances)
+        return Promise.resolve();
+    if (Array.isArray(instances)) {
+        return Promise.all(instances.map((instance) => {
+            const { options: instanceOptions } = instance.constructor;
+            return handleChildrenAfterFindHook(instance, instanceOptions, level);
+        }));
+    }
+    const instance = instances;
+    const { constructor } = instance;
+    /**
+         * Root model will have already run their "afterFind" hook.
+         * Only run children "afterFind" hooks.
+         */
+    if (level >= 1) {
+        await constructor.runHooks('afterFind', instance, options);
+    }
+    const { associations } = constructor;
+    const associatedNames = Object.keys(instance).filter((attribute) => Object.keys(associations).includes(attribute));
+    if (associatedNames.length) {
+        const childInstances = associatedNames.map((name) => instance[name]);
+        return handleChildrenAfterFindHook(childInstances, options, level + 1);
+    }
+    return Promise.resolve();
+};
+exports.default = handleChildrenAfterFindHook;

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import type { Application } from 'express';
+import { Sequelize } from 'sequelize-typescript';
+import type { CustomFieldOptions, ModelFetcher } from './types';
+export * from './utils/validations/custom-fields';
+export * from './utils/constants';
+export * from './utils/helpers';
+export { CustomFieldDefinitionType } from './utils/validations/type';
+/**
+ * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
+ * @see {@link 'custom-fields/config'} for configurations
+ */
+declare const useCustomFields: (app: Application | null, getModel: ModelFetcher, options: CustomFieldOptions) => Promise<Sequelize>;
+export default useCustomFields;
+export declare const disableCustomFields: (models: any, getModel: any) => void;

package/dist/index.js

@@ -0,0 +1,56 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disableCustomFields = exports.CustomFieldDefinitionType = void 0;
+const models_1 = require("./models");
+const api_1 = __importDefault(require("./api"));
+const db_1 = __importDefault(require("./utils/db"));
+const logger_1 = __importDefault(require("./utils/logger"));
+const init_1 = require("./utils/init");
+__exportStar(require("./utils/validations/custom-fields"), exports);
+__exportStar(require("./utils/constants"), exports);
+__exportStar(require("./utils/helpers"), exports);
+var type_1 = require("./utils/validations/type");
+Object.defineProperty(exports, "CustomFieldDefinitionType", { enumerable: true, get: function () { return type_1.CustomFieldDefinitionType; } });
+/**
+ * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
+ * @see {@link 'custom-fields/config'} for configurations
+ */
+const useCustomFields = async (app, getModel, options) => {
+    const { models } = options;
+    if (app) {
+        app.use('/api', api_1.default);
+    }
+    const sequelize = (0, db_1.default)(options.databaseConfig);
+    if (process.env.NODE_ENV === 'test') {
+        await (0, models_1.initTestModels)(sequelize);
+    }
+    // The order is important
+    (0, init_1.addHooks)(models, getModel);
+    await (0, models_1.initTables)(sequelize, options.getUser);
+    (0, init_1.addScopes)(models, getModel);
+    (0, init_1.applyCustomAssociation)(models);
+    logger_1.default.debug('sadot - custom fields finished initializing with models', models);
+    return sequelize;
+};
+exports.default = useCustomFields;
+const disableCustomFields = (models, getModel) => {
+    (0, init_1.removeHooks)(models, getModel);
+};
+exports.disableCustomFields = disableCustomFields;

package/dist/models/CustomFieldDefinition.d.ts

@@ -0,0 +1,23 @@
+import { Model } from 'sequelize-typescript';
+import { CustomFieldDefinitionType } from '../utils/validations/type';
+import { CustomFieldValue } from '.';
+declare class CustomFieldDefinition extends Model {
+    id: string;
+    name: string;
+    displayName?: string;
+    fieldType: CustomFieldDefinitionType;
+    validation?: any;
+    entityId: string; /** Client association entity id */
+    entityType: string; /** Client association entity type (demand source / fleet / etc.) */
+    modelType: string; /** Model type. e.g. Vehicle / StopPoint / etc. */
+    description?: string;
+    required?: boolean;
+    disabled?: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    values: CustomFieldValue[];
+    static displayNameDefaultValue(instance: CustomFieldDefinition): void;
+    static afterSaveHandler(instance: CustomFieldDefinition, options: any): void;
+}
+export default CustomFieldDefinition;

package/dist/models/CustomFieldDefinition.js

@@ -0,0 +1,165 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
+const sequelize_typescript_1 = require("sequelize-typescript");
+const custom_1 = require("../utils/validations/custom");
+const type_1 = require("../utils/validations/type");
+const _1 = require(".");
+const events_1 = require("../events");
+const errors_1 = require("../errors");
+let CustomFieldDefinition = class CustomFieldDefinition extends sequelize_typescript_1.Model {
+    static displayNameDefaultValue(instance) {
+        if (!instance?.displayName) {
+            // eslint-disable-next-line no-param-reassign
+            instance.displayName = instance.name;
+        }
+    }
+    static afterSaveHandler(instance, options) {
+        if (options.transaction) {
+            options.transaction.afterCommit(() => (0, events_1.sendDimEvent)(instance));
+        }
+        else {
+            (0, events_1.sendDimEvent)(instance);
+        }
+    }
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        defaultValue: sequelize_typescript_1.DataType.UUIDV4,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], CustomFieldDefinition.prototype, "id", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.STRING,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], CustomFieldDefinition.prototype, "name", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.STRING,
+    }),
+    __metadata("design:type", String)
+], CustomFieldDefinition.prototype, "displayName", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Is)('SupportedType', (value) => {
+        if (!Object.values(type_1.CustomFieldDefinitionType).includes(value)) {
+            throw new errors_1.UnsupportedCustomFieldTypeError(`"${value}" is not a supported type.`);
+        }
+    }),
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.STRING,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], CustomFieldDefinition.prototype, "fieldType", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.JSONB,
+    }),
+    __metadata("design:type", Object)
+], CustomFieldDefinition.prototype, "validation", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], CustomFieldDefinition.prototype, "entityId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.STRING,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], CustomFieldDefinition.prototype, "entityType", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.STRING,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], CustomFieldDefinition.prototype, "modelType", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.TEXT,
+    }),
+    __metadata("design:type", String)
+], CustomFieldDefinition.prototype, "description", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BOOLEAN,
+        defaultValue: false,
+    }),
+    __metadata("design:type", Boolean)
+], CustomFieldDefinition.prototype, "required", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.BOOLEAN,
+        defaultValue: false,
+    }),
+    __metadata("design:type", Boolean)
+], CustomFieldDefinition.prototype, "disabled", void 0);
+__decorate([
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], CustomFieldDefinition.prototype, "createdAt", void 0);
+__decorate([
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], CustomFieldDefinition.prototype, "updatedAt", void 0);
+__decorate([
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], CustomFieldDefinition.prototype, "deletedAt", void 0);
+__decorate([
+    (0, sequelize_typescript_1.HasMany)(() => _1.CustomFieldValue),
+    __metadata("design:type", Array)
+], CustomFieldDefinition.prototype, "values", void 0);
+__decorate([
+    sequelize_typescript_1.BeforeCreate,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CustomFieldDefinition]),
+    __metadata("design:returntype", void 0)
+], CustomFieldDefinition, "displayNameDefaultValue", null);
+__decorate([
+    sequelize_typescript_1.AfterSave,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CustomFieldDefinition, Object]),
+    __metadata("design:returntype", void 0)
+], CustomFieldDefinition, "afterSaveHandler", null);
+CustomFieldDefinition = __decorate([
+    (0, sequelize_typescript_1.DefaultScope)(() => ({ where: { disabled: false } })),
+    (0, sequelize_typescript_1.Table)({
+        indexes: [
+            {
+                name: 'unique_name_model_type',
+                fields: ['model_type', 'entity_id', 'name'],
+                unique: true,
+            },
+        ],
+        timestamps: true,
+        validate: {
+            validationByType() {
+                if (!(0, custom_1.validateValidation)(this.fieldType, this.validation)) {
+                    throw new errors_1.UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
+                }
+            },
+        },
+    })
+], CustomFieldDefinition);
+exports.default = CustomFieldDefinition;

package/dist/models/CustomFieldValue.d.ts

@@ -0,0 +1,15 @@
+import { Model } from 'sequelize-typescript';
+import { CustomFieldDefinition } from '.';
+declare class CustomFieldValue extends Model {
+    modelId: string;
+    customFieldDefinitionId: string;
+    value: any;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+    customFieldDefinition: CustomFieldDefinition;
+    static validateValues(instances: CustomFieldValue[]): Promise<void>;
+    static validateValue(instance: CustomFieldValue): Promise<void>;
+    static afterSaveHandler(instance: CustomFieldValue, options: any): void;
+}
+export default CustomFieldValue;

package/dist/models/CustomFieldValue.js

@@ -0,0 +1,148 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
+const sequelize_typescript_1 = require("sequelize-typescript");
+const events_1 = require("../events");
+const _1 = require(".");
+const validations_1 = __importDefault(require("../utils/validations"));
+const CustomFieldDefinitionRepo = __importStar(require("../repository/definition"));
+const errors_1 = require("../errors");
+let CustomFieldValue = class CustomFieldValue extends sequelize_typescript_1.Model {
+    static async validateValues(instances) {
+        const ids = instances.map((instance) => instance.customFieldDefinitionId);
+        const uniqueIds = [...new Set(ids)];
+        const definitions = await CustomFieldDefinitionRepo.findByIds(uniqueIds, { withDisabled: true });
+        if (!definitions || definitions.length !== uniqueIds.length) {
+            throw new Error('Definitions not found');
+        }
+        instances.forEach((instance) => {
+            const { validation, fieldType, } = definitions
+                .find((definition) => definition.id === instance.customFieldDefinitionId);
+            const isValid = (0, validations_1.default)(instance.value, fieldType, validation);
+            if (!isValid) {
+                throw new errors_1.InvalidValueError(instance.value, fieldType);
+            }
+        });
+    }
+    static async validateValue(instance) {
+        const { customFieldDefinitionId } = instance;
+        // eslint-disable-next-line max-len
+        const cfd = await CustomFieldDefinitionRepo.findById(customFieldDefinitionId, { withDisabled: true });
+        const { validation, fieldType } = cfd;
+        const isValid = (0, validations_1.default)(instance.value, fieldType, validation);
+        if (!isValid) {
+            throw new errors_1.InvalidValueError(instance.value, fieldType);
+        }
+    }
+    static afterSaveHandler(instance, options) {
+        if (options.transaction) {
+            options.transaction.afterCommit(() => (0, events_1.sendDimEvent)(instance[0]));
+        }
+        else {
+            (0, events_1.sendDimEvent)(instance[0]);
+        }
+    }
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], CustomFieldValue.prototype, "modelId", void 0);
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (0, sequelize_typescript_1.ForeignKey)(() => _1.CustomFieldDefinition),
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    }),
+    __metadata("design:type", String)
+], CustomFieldValue.prototype, "customFieldDefinitionId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.JSONB,
+        allowNull: true,
+    }),
+    __metadata("design:type", Object)
+], CustomFieldValue.prototype, "value", void 0);
+__decorate([
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], CustomFieldValue.prototype, "createdAt", void 0);
+__decorate([
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], CustomFieldValue.prototype, "updatedAt", void 0);
+__decorate([
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], CustomFieldValue.prototype, "deletedAt", void 0);
+__decorate([
+    (0, sequelize_typescript_1.BelongsTo)(() => _1.CustomFieldDefinition, { scope: { disabled: false } }),
+    __metadata("design:type", _1.CustomFieldDefinition)
+], CustomFieldValue.prototype, "customFieldDefinition", void 0);
+__decorate([
+    sequelize_typescript_1.BeforeBulkCreate,
+    sequelize_typescript_1.BeforeBulkUpdate,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], CustomFieldValue, "validateValues", null);
+__decorate([
+    sequelize_typescript_1.BeforeUpdate,
+    sequelize_typescript_1.BeforeCreate,
+    sequelize_typescript_1.BeforeUpsert,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CustomFieldValue]),
+    __metadata("design:returntype", Promise)
+], CustomFieldValue, "validateValue", null);
+__decorate([
+    sequelize_typescript_1.AfterUpsert,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CustomFieldValue, Object]),
+    __metadata("design:returntype", void 0)
+], CustomFieldValue, "afterSaveHandler", null);
+CustomFieldValue = __decorate([
+    (0, sequelize_typescript_1.Table)({
+        timestamps: true,
+    })
+], CustomFieldValue);
+exports.default = CustomFieldValue;

package/dist/models/index.d.ts

@@ -0,0 +1,10 @@
+import type { Sequelize } from 'sequelize-typescript';
+import CustomFieldDefinition from './CustomFieldDefinition';
+import CustomFieldValue from './CustomFieldValue';
+import TestModel from './tests/TestModel';
+import ContextAwareTestModel from './tests/contextAwareModels/ContextAwareTestModel';
+import ContextTestModel from './tests/contextAwareModels/ContextTestModel';
+import AssociatedTestModel from './tests/AssociatedTestModel';
+declare const initTables: (sequelize: Sequelize, getUser: any) => Promise<void>;
+declare const initTestModels: (sequelize: Sequelize) => Promise<void>;
+export { CustomFieldValue, CustomFieldDefinition, TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel, initTables, initTestModels, };

package/dist/models/index.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTestModels = exports.initTables = exports.ContextTestModel = exports.ContextAwareTestModel = exports.AssociatedTestModel = exports.TestModel = exports.CustomFieldDefinition = exports.CustomFieldValue = void 0;
+/* eslint-disable no-param-reassign */
+const sequelize_1 = require("sequelize");
+const logger_1 = __importDefault(require("../utils/logger"));
+const CustomFieldDefinition_1 = __importDefault(require("./CustomFieldDefinition"));
+exports.CustomFieldDefinition = CustomFieldDefinition_1.default;
+const CustomFieldValue_1 = __importDefault(require("./CustomFieldValue"));
+exports.CustomFieldValue = CustomFieldValue_1.default;
+const TestModel_1 = __importDefault(require("./tests/TestModel"));
+exports.TestModel = TestModel_1.default;
+const ContextAwareTestModel_1 = __importDefault(require("./tests/contextAwareModels/ContextAwareTestModel"));
+exports.ContextAwareTestModel = ContextAwareTestModel_1.default;
+const ContextTestModel_1 = __importDefault(require("./tests/contextAwareModels/ContextTestModel"));
+exports.ContextTestModel = ContextTestModel_1.default;
+const AssociatedTestModel_1 = __importDefault(require("./tests/AssociatedTestModel"));
+exports.AssociatedTestModel = AssociatedTestModel_1.default;
+const productionModels = [CustomFieldDefinition_1.default, CustomFieldValue_1.default];
+const testModels = [TestModel_1.default, AssociatedTestModel_1.default, ContextAwareTestModel_1.default, ContextTestModel_1.default];
+const SADOT_MIGRATION_PREFIX = 'sadot-migration';
+const SCHEMA_VERSION = 1;
+const CUSTOM_FIELDS_SCHEMA_VERSION = `${SADOT_MIGRATION_PREFIX}_${SCHEMA_VERSION}`;
+const initTables = async (sequelize, getUser) => {
+    logger_1.default.info('custom-fields: initialize custom-fields tables');
+    // Detect models and import them to the orm
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    if (!sequelize.addModels) {
+        throw new Error('sequelize instance must have addModels function');
+    }
+    sequelize.addModels(productionModels);
+    CustomFieldDefinition_1.default.addScope('userScope', () => {
+        const user = getUser();
+        if (user?.permissions) {
+            return {
+                where: {
+                    entityId: [
+                        ...Object.keys(user.permissions.fleets),
+                        ...Object.keys(user.permissions.businessModels),
+                        ...Object.keys(user.permissions.demandSources),
+                    ],
+                },
+            };
+        }
+        return {};
+    });
+    logger_1.default.info('custom-fields: models added');
+    const SequelizeMeta = sequelize.define('SequelizeMeta', {
+        name: {
+            type: sequelize_1.DataTypes.STRING,
+            allowNull: false,
+            unique: true,
+            primaryKey: true,
+            autoIncrement: false,
+        },
+    }, {
+        tableName: 'SequelizeMeta',
+        timestamps: false,
+        schema: 'public',
+    });
+    const migrations = await SequelizeMeta.findAll({ raw: true });
+    const currentSadotSchemaVersion = migrations
+        .reverse().find((m) => m.name.includes(SADOT_MIGRATION_PREFIX));
+    if (!currentSadotSchemaVersion
+        || currentSadotSchemaVersion.name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
+        await CustomFieldDefinition_1.default.sync({ alter: true });
+        await CustomFieldValue_1.default.sync({ alter: true });
+        await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
+        logger_1.default.info('custom-fields: models synced');
+    }
+};
+exports.initTables = initTables;
+const initTestModels = async (sequelize) => {
+    logger_1.default.info('custom-fields: initialize custom-fields test models');
+    // Detect models and import them to the orm
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    if (!sequelize.addModels) {
+        throw new Error('sequelize instance must have addModels function');
+    }
+    sequelize.addModels(testModels);
+    await sequelize.dropSchema('custom-fields', { logging: false });
+    await sequelize.createSchema('custom-fields', { logging: false });
+    logger_1.default.info('custom-fields: test models added');
+    await TestModel_1.default.sync({ alter: true });
+    await AssociatedTestModel_1.default.sync({ alter: true });
+    await ContextTestModel_1.default.sync({ alter: true });
+    await ContextAwareTestModel_1.default.sync({ alter: true });
+    logger_1.default.info('custom-fields: test models synced');
+};
+exports.initTestModels = initTestModels;

package/dist/models/tests/AssociatedTestModel.d.ts

@@ -0,0 +1,12 @@
+import { Model } from 'sequelize-typescript';
+import TestModel from './TestModel';
+declare class AssociatedTestModel extends Model {
+    id: string;
+    testModelId: string;
+    fleetId: string;
+    businessModelId: string;
+    demandSourceId: string;
+    anotherAttribute?: boolean;
+    testModel: TestModel;
+}
+export default AssociatedTestModel;