@autofleet/sadot 0.0.1-beta.9 → 0.0.2-beta

package/dist/src/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 → src/hooks}/workaround.js

@@ -7,17 +7,8 @@
  * which manually calls the afterFind hook of each model, recursively
  * https://github.com/sequelize/sequelize/issues/4627
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const handleChildrenAfterFindHook = (instances, options, level = 0) => __awaiter(void 0, void 0, void 0, function* () {
+const handleChildrenAfterFindHook = async (instances, options, level = 0) => {
     if (!instances)
         return Promise.resolve();
     if (Array.isArray(instances)) {
@@ -33,7 +24,7 @@ const handleChildrenAfterFindHook = (instances, options, level = 0) => __awaiter
          * Only run children "afterFind" hooks.
          */
     if (level >= 1) {
-        yield constructor.runHooks('afterFind', instance, options);
+        await constructor.runHooks('afterFind', instance, options);
     }
     const { associations } = constructor;
     const associatedNames = Object.keys(instance).filter((attribute) => Object.keys(associations).includes(attribute));
@@ -42,6 +33,5 @@ const handleChildrenAfterFindHook = (instances, options, level = 0) => __awaiter
         return handleChildrenAfterFindHook(childInstances, options, level + 1);
     }
     return Promise.resolve();
-});
+};
 exports.default = handleChildrenAfterFindHook;
-//# sourceMappingURL=workaround.js.map

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+import type { Application } from 'express';
+import { Sequelize } from 'sequelize-typescript';
+import { CustomFieldOptions, ModelFetcher } from './types';
+export * from './utils/validations/custom-fields';
+/**
+ * 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/src/index.js

@@ -0,0 +1,105 @@
+"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 = void 0;
+const sequelize_1 = require("sequelize");
+const models_1 = require("./models");
+const api_1 = __importDefault(require("./api"));
+const hooks_1 = require("./hooks");
+const db_1 = __importDefault(require("./utils/db"));
+const logger_1 = __importDefault(require("./utils/logger"));
+__exportStar(require("./utils/validations/custom-fields"), exports);
+const addHooks = (models, getModel) => {
+    models.forEach(async ({ name, scopeAttributes }) => {
+        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));
+            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes));
+            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes));
+            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes));
+            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes));
+        }
+        catch (e) {
+            logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
+        }
+    });
+};
+/**
+ * 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);
+    }
+    addHooks(models, getModel);
+    await (0, models_1.initTables)(sequelize, options.getUser);
+    logger_1.default.debug('sadot - custom fields finished initializing with models', models);
+    return sequelize;
+};
+exports.default = useCustomFields;
+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);
+        }
+    });
+};
+const disableCustomFields = (models, getModel) => {
+    removeHooks(models, getModel);
+};
+exports.disableCustomFields = disableCustomFields;

package/dist/src/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 → src/models}/CustomFieldDefinition.js

@@ -9,28 +9,17 @@ 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 });
-exports.CustomFieldDefinitionType = void 0;
 /* 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");
-/**
- * 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["ENUM"] = "enum";
-})(CustomFieldDefinitionType = exports.CustomFieldDefinitionType || (exports.CustomFieldDefinitionType = {}));
+const errors_1 = require("../errors");
 let CustomFieldDefinition = class CustomFieldDefinition extends sequelize_typescript_1.Model {
     static displayNameDefaultValue(instance) {
-        if (!(instance === null || instance === void 0 ? void 0 : instance.displayName)) {
+        if (!instance?.displayName) {
             // eslint-disable-next-line no-param-reassign
             instance.displayName = instance.name;
         }
@@ -67,6 +56,11 @@ __decorate([
     __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,
@@ -152,10 +146,20 @@ CustomFieldDefinition = __decorate([
     (0, sequelize_typescript_1.DefaultScope)(() => ({ where: { disabled: false } })),
     (0, sequelize_typescript_1.Table)({
         indexes: [
-            { name: "unique_name_model_type", fields: ["name", "model_type", "entity_id"], unique: true },
+            {
+                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;
-//# sourceMappingURL=CustomFieldDefinition.js.map

package/dist/src/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 → src/models}/CustomFieldValue.js

@@ -31,61 +31,46 @@ var __importStar = (this && this.__importStar) || function (mod) {
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 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 logger_1 = __importDefault(require("../utils/logger"));
+const errors_1 = require("../errors");
 let CustomFieldValue = class CustomFieldValue extends sequelize_typescript_1.Model {
-    static validateValues(instances) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.default.info('CustomFieldValue BeforeBulkCreate/BeforeBulkUpdate', { instances });
-            const ids = instances.map((instance) => instance.customFieldDefinitionId);
-            const uniqueIds = [...new Set(ids)];
-            const definitions = yield 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 Error('Invalid value');
-                }
-            });
-        });
-    }
-    static validateValue(instance) {
-        return __awaiter(this, void 0, void 0, function* () {
-            logger_1.default.info('CustomFieldValue BeforeCreate/BeforeUpdate', { instance });
-            const { customFieldDefinitionId } = instance;
-            // eslint-disable-next-line max-len
-            const cfd = yield CustomFieldDefinitionRepo.findById(customFieldDefinitionId, { withDisabled: true });
-            const { validation, fieldType } = cfd;
+    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 Error('Invalid value');
+                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) {
-        logger_1.default.info('CustomFieldValue afterSave', { instance });
         if (options.transaction) {
             options.transaction.afterCommit(() => (0, events_1.sendDimEvent)(instance[0]));
         }
@@ -114,7 +99,7 @@ __decorate([
 __decorate([
     (0, sequelize_typescript_1.Column)({
         type: sequelize_typescript_1.DataType.JSONB,
-        allowNull: false,
+        allowNull: true,
     }),
     __metadata("design:type", Object)
 ], CustomFieldValue.prototype, "value", void 0);
@@ -161,4 +146,3 @@ CustomFieldValue = __decorate([
     })
 ], CustomFieldValue);
 exports.default = CustomFieldValue;
-//# sourceMappingURL=CustomFieldValue.js.map

package/dist/src/models/index.d.ts

@@ -0,0 +1,8 @@
+import type { Sequelize } from 'sequelize-typescript';
+import CustomFieldDefinition from './CustomFieldDefinition';
+import CustomFieldValue from './CustomFieldValue';
+import TestModel from './tests/TestModel';
+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, initTables, initTestModels, };

package/dist/src/models/index.js

@@ -0,0 +1,87 @@
+"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.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 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];
+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 });
+    logger_1.default.info('custom-fields: test models synced');
+};
+exports.initTestModels = initTestModels;

package/dist/src/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;

package/dist/{models → src/models}/tests/AssociatedTestModel.js

@@ -69,4 +69,3 @@ AssociatedTestModel = __decorate([
     (0, sequelize_typescript_1.Table)({ schema: 'custom-fields', createdAt: false, updatedAt: false })
 ], AssociatedTestModel);
 exports.default = AssociatedTestModel;
-//# sourceMappingURL=AssociatedTestModel.js.map

package/dist/src/models/tests/TestModel.d.ts

@@ -0,0 +1,11 @@
+import { Model } from 'sequelize-typescript';
+import AssociatedTestModel from './AssociatedTestModel';
+declare class TestModel extends Model {
+    id: string;
+    fleetId: string;
+    businessModelId: string;
+    demandSourceId: string;
+    coolAttribute?: boolean;
+    associatedModels: AssociatedTestModel[];
+}
+export default TestModel;

package/dist/{models → src/models}/tests/TestModel.js

@@ -61,4 +61,3 @@ TestModel = __decorate([
     (0, sequelize_typescript_1.Table)({ schema: 'custom-fields', createdAt: false, updatedAt: false })
 ], TestModel);
 exports.default = TestModel;
-//# sourceMappingURL=TestModel.js.map

package/dist/src/repository/definition.d.ts

@@ -0,0 +1,17 @@
+import { CustomFieldDefinition } from '../models';
+import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
+export declare const create: (data: CreateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
+export declare const findAll: (where: any, options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findByIds: (ids: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findById: (id: string, options?: any) => Promise<CustomFieldDefinition | null>;
+export declare const findByEntityId: (entityId: string, options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findByEntityIds: (modelType: string, entityIds: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findByWhere: (where: any) => Promise<CustomFieldDefinition | null>;
+export declare const findDefinitionsByModels: (modelTypes: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const update: (id: string, data: UpdateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
+export declare const disable: (id: string) => Promise<any>;
+export declare const destroy: (id: string) => Promise<any>;
+/**
+ * Return the names of the required fields for a given model
+ */
+export declare const getRequiredFields: (modelType: string, modelId: string | string[], entityId: string | string[]) => Promise<string[]>;

package/dist/src/repository/definition.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequiredFields = exports.destroy = exports.disable = exports.update = exports.findDefinitionsByModels = exports.findByWhere = exports.findByEntityIds = exports.findByEntityId = exports.findById = exports.findByIds = exports.findAll = exports.create = void 0;
+const sequelize_1 = require("sequelize");
+const models_1 = require("../models");
+const create = (data) => models_1.CustomFieldDefinition.create(data);
+exports.create = create;
+const findAll = (where, options = { withDisabled: false }) => {
+    const queryModel = options.withDisabled
+        ? models_1.CustomFieldDefinition.unscoped()
+        : models_1.CustomFieldDefinition;
+    return queryModel.scope('userScope').findAll({
+        where,
+        transaction: options.transaction,
+        raw: true,
+    });
+};
+exports.findAll = findAll;
+const findByIds = (ids, options = { withDisabled: false }) => (0, exports.findAll)({ id: { [sequelize_1.Op.in]: ids } }, options);
+exports.findByIds = findByIds;
+const findById = (id, options = { withDisabled: false }) => {
+    const { withDisabled } = options;
+    if (withDisabled) {
+        return models_1.CustomFieldDefinition.unscoped().scope('userScope').findByPk(id);
+    }
+    return models_1.CustomFieldDefinition.scope('userScope').findByPk(id);
+};
+exports.findById = findById;
+const findByEntityId = async (entityId, options = {}) => models_1.CustomFieldDefinition.findAll({
+    where: { entityId },
+    transaction: options.transaction,
+});
+exports.findByEntityId = findByEntityId;
+const findByEntityIds = async (modelType, entityIds, options = {}) => models_1.CustomFieldDefinition.findAll({
+    where: {
+        modelType,
+        entityId: entityIds,
+    },
+    transaction: options.transaction,
+    raw: true,
+});
+exports.findByEntityIds = findByEntityIds;
+const findByWhere = (where) => models_1.CustomFieldDefinition.scope('userScope').findOne({
+    where,
+});
+exports.findByWhere = findByWhere;
+const findDefinitionsByModels = async (modelTypes, options) => {
+    const query = { modelType: { [sequelize_1.Op.in]: modelTypes } };
+    return models_1.CustomFieldDefinition.findAll({
+        where: query,
+        transaction: options?.transaction,
+    });
+};
+exports.findDefinitionsByModels = findDefinitionsByModels;
+const update = async (id, data) => {
+    const updatedDefinition = (await models_1.CustomFieldDefinition.scope('userScope').update(data, {
+        where: { id },
+        returning: true,
+        individualHooks: true,
+    }))[1][0];
+    return updatedDefinition;
+};
+exports.update = update;
+const disable = (id) => models_1.CustomFieldDefinition.update({ disabled: true }, { where: { id } });
+exports.disable = disable;
+const destroy = (id) => models_1.CustomFieldDefinition.destroy({ where: { id } });
+exports.destroy = destroy;
+/**
+ * Return the names of the required fields for a given model
+ */
+const getRequiredFields = async (modelType, modelId, entityId) => {
+    const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+    const requiredFields = await models_1.CustomFieldDefinition.findAll({
+        where: { required: true, modelType, entityId: { [sequelize_1.Op.in]: entityIds } },
+        logging: true,
+    });
+    const requiredFieldsNames = requiredFields.map((definition) => definition.name);
+    return [...new Set(requiredFieldsNames)];
+};
+exports.getRequiredFields = getRequiredFields;

package/dist/src/repository/value.d.ts

@@ -0,0 +1,24 @@
+import { CustomFieldValue } from '../models';
+import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+export declare const findByModelIdAndDefinition: (modelId: string, customFieldDefinitionId: string) => Promise<CustomFieldValue[]>;
+export declare const create: (data: CreateCustomFieldValue, withAssociations?: boolean) => Promise<CustomFieldValue>;
+export declare const findAllValues: () => Promise<CustomFieldValue[]>;
+/**
+ * Get all values for model instance id (with their definitions)
+ * @param modelId
+ * @returns CustomFieldValue[]
+ */
+export declare const findValuesByModelId: (modelId: string) => Promise<CustomFieldValue[]>;
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+export declare const findValuesByModelIds: (modelIds: string[], options?: any) => Promise<CustomFieldValue[]>;
+/**
+ * Try to update custom field values for a model instance.
+ * Create new value record if not exists, but fails if value's definition not exist.
+ * Return the updated values
+ */
+export declare const updateValues: (modelType: string, modelId: string, identifiers: string[], valuesToUpdate: ValuesToUpdate, options?: any) => Promise<CustomFieldValue[]>;
+export declare const deleteValue: (id: string, options?: any) => Promise<any>;