@autofleet/sadot 0.3.1 → 0.3.3

package/dist/models/CustomFieldDefinition.js

@@ -19,7 +19,7 @@ const events_1 = require("../events");
 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;
         }
@@ -163,4 +163,3 @@ CustomFieldDefinition = __decorate([
     })
 ], CustomFieldDefinition);
 exports.default = CustomFieldDefinition;
-//# sourceMappingURL=CustomFieldDefinition.js.map

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

@@ -31,15 +31,6 @@ 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 };
 };
@@ -53,36 +44,32 @@ 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 validateValues(instances) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 errors_1.InvalidValueError(instance.value, fieldType);
-                }
-            });
-        });
-    }
-    static validateValue(instance) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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 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]));
@@ -159,4 +146,3 @@ CustomFieldValue = __decorate([
     })
 ], CustomFieldValue);
 exports.default = CustomFieldValue;
-//# sourceMappingURL=CustomFieldValue.js.map

package/dist/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/models/index.js

@@ -1,13 +1,4 @@
 "use strict";
-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 };
 };
@@ -29,7 +20,7 @@ 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 = (sequelize, getUser) => __awaiter(void 0, void 0, void 0, function* () {
+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
@@ -39,7 +30,7 @@ const initTables = (sequelize, getUser) => __awaiter(void 0, void 0, void 0, fun
     sequelize.addModels(productionModels);
     CustomFieldDefinition_1.default.addScope('userScope', () => {
         const user = getUser();
-        if (user === null || user === void 0 ? void 0 : user.permissions) {
+        if (user?.permissions) {
             return {
                 where: {
                     entityId: [
@@ -66,19 +57,19 @@ const initTables = (sequelize, getUser) => __awaiter(void 0, void 0, void 0, fun
         timestamps: false,
         schema: 'public',
     });
-    const migrations = yield SequelizeMeta.findAll({ raw: true });
+    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) {
-        yield CustomFieldDefinition_1.default.sync({ alter: true });
-        yield CustomFieldValue_1.default.sync({ alter: true });
-        yield SequelizeMeta.create({ 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 = (sequelize) => __awaiter(void 0, void 0, void 0, function* () {
+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
@@ -86,12 +77,11 @@ const initTestModels = (sequelize) => __awaiter(void 0, void 0, void 0, function
         throw new Error('sequelize instance must have addModels function');
     }
     sequelize.addModels(testModels);
-    yield sequelize.dropSchema('custom-fields', { logging: false });
-    yield sequelize.createSchema('custom-fields', { logging: false });
+    await sequelize.dropSchema('custom-fields', { logging: false });
+    await sequelize.createSchema('custom-fields', { logging: false });
     logger_1.default.info('custom-fields: test models added');
-    yield TestModel_1.default.sync({ alter: true });
-    yield AssociatedTestModel_1.default.sync({ alter: true });
+    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;
-//# sourceMappingURL=index.js.map

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;

package/dist/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/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/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/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/repository/definition.js

@@ -1,13 +1,4 @@
 "use strict";
-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 });
 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");
@@ -35,44 +26,40 @@ const findById = (id, options = { withDisabled: false }) => {
     return models_1.CustomFieldDefinition.scope('userScope').findByPk(id);
 };
 exports.findById = findById;
-const findByEntityId = (entityId, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    return models_1.CustomFieldDefinition.findAll({
-        where: { entityId },
-        transaction: options.transaction,
-    });
+const findByEntityId = async (entityId, options = {}) => models_1.CustomFieldDefinition.findAll({
+    where: { entityId },
+    transaction: options.transaction,
 });
 exports.findByEntityId = findByEntityId;
-const findByEntityIds = (modelType, entityIds, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    return models_1.CustomFieldDefinition.findAll({
-        where: {
-            modelType,
-            entityId: entityIds,
-        },
-        transaction: options.transaction,
-        raw: true,
-    });
+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 = (modelTypes, options) => __awaiter(void 0, void 0, void 0, function* () {
+const findDefinitionsByModels = async (modelTypes, options) => {
     const query = { modelType: { [sequelize_1.Op.in]: modelTypes } };
     return models_1.CustomFieldDefinition.findAll({
         where: query,
-        transaction: options === null || options === void 0 ? void 0 : options.transaction,
+        transaction: options?.transaction,
     });
-});
+};
 exports.findDefinitionsByModels = findDefinitionsByModels;
-const update = (id, data) => __awaiter(void 0, void 0, void 0, function* () {
-    const updatedDefinition = (yield models_1.CustomFieldDefinition.scope('userScope').update(data, {
+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;
@@ -81,14 +68,13 @@ exports.destroy = destroy;
 /**
  * Return the names of the required fields for a given model
  */
-const getRequiredFields = (modelType, modelId, entityId) => __awaiter(void 0, void 0, void 0, function* () {
+const getRequiredFields = async (modelType, modelId, entityId) => {
     const entityIds = Array.isArray(entityId) ? entityId : [entityId];
-    const requiredFields = yield models_1.CustomFieldDefinition.findAll({
+    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;
-//# sourceMappingURL=definition.js.map

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

package/dist/repository/value.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 };
 };
@@ -41,32 +32,32 @@ const models_1 = require("../models");
 const DefinitionRepo = __importStar(require("./definition"));
 const logger_1 = __importDefault(require("../utils/logger"));
 const errors_1 = require("../errors");
-const findByModelIdAndDefinition = (modelId, customFieldDefinitionId) => __awaiter(void 0, void 0, void 0, function* () { return models_1.CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [models_1.CustomFieldDefinition] }); });
+const findByModelIdAndDefinition = async (modelId, customFieldDefinitionId) => models_1.CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [models_1.CustomFieldDefinition] });
 exports.findByModelIdAndDefinition = findByModelIdAndDefinition;
-const create = (data, withAssociations = false) => __awaiter(void 0, void 0, void 0, function* () {
-    const created = yield models_1.CustomFieldValue.create(data);
+const create = async (data, withAssociations = false) => {
+    const created = await models_1.CustomFieldValue.create(data);
     if (withAssociations) {
-        const createdWithAssociations = yield (0, exports.findByModelIdAndDefinition)(created.modelId, created.customFieldDefinitionId);
-        return createdWithAssociations === null || createdWithAssociations === void 0 ? void 0 : createdWithAssociations[0];
+        const createdWithAssociations = await (0, exports.findByModelIdAndDefinition)(created.modelId, created.customFieldDefinitionId);
+        return createdWithAssociations?.[0];
     }
     return created;
-});
+};
 exports.create = create;
-const findAllValues = () => __awaiter(void 0, void 0, void 0, function* () { return models_1.CustomFieldValue.findAll({ include: [models_1.CustomFieldDefinition] }); });
+const findAllValues = async () => models_1.CustomFieldValue.findAll({ include: [models_1.CustomFieldDefinition] });
 exports.findAllValues = findAllValues;
 /**
  * Get all values for model instance id (with their definitions)
  * @param modelId
  * @returns CustomFieldValue[]
  */
-const findValuesByModelId = (modelId) => __awaiter(void 0, void 0, void 0, function* () { return models_1.CustomFieldValue.findAll({ where: { modelId }, include: [models_1.CustomFieldDefinition] }); });
+const findValuesByModelId = async (modelId) => models_1.CustomFieldValue.findAll({ where: { modelId }, include: [models_1.CustomFieldDefinition] });
 exports.findValuesByModelId = findValuesByModelId;
 /**
 * 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.
 */
-const findValuesByModelIds = (modelIds, options) => __awaiter(void 0, void 0, void 0, function* () {
+const findValuesByModelIds = async (modelIds, options) => {
     const { transaction } = options;
     return models_1.CustomFieldValue.findAll({
         where: { modelId: modelIds },
@@ -74,25 +65,25 @@ const findValuesByModelIds = (modelIds, options) => __awaiter(void 0, void 0, vo
         raw: true,
         nest: true,
     });
-});
+};
 exports.findValuesByModelIds = findValuesByModelIds;
 /**
  * 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
  */
-const updateValues = (modelType, modelId, identifiers, valuesToUpdate, options = {}) => __awaiter(void 0, void 0, void 0, function* () {
+const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
     logger_1.default.info(`custom-fields: updating values for ${modelType} ${modelId}`, { valuesToUpdate });
     const names = Object.keys(valuesToUpdate);
-    const fieldDefinitions = (yield DefinitionRepo.findAll({ modelType, name: names, entityId: identifiers }, { withDisabled: true, transaction: options.transaction })) || [];
+    const fieldDefinitions = await DefinitionRepo.findAll({ modelType, name: names, entityId: identifiers }, { withDisabled: true, transaction: options.transaction }) || [];
     const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
     if (fieldDefinitions.length !== names.length) {
         const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
         throw new errors_1.MissingDefinitionError(missingDefinitions);
     }
-    const disabledNames = (disabledDefinitions === null || disabledDefinitions === void 0 ? void 0 : disabledDefinitions.map((def) => def.name)) || [];
+    const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
     const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
-    if ((valuesWithDisabledDefinitions === null || valuesWithDisabledDefinitions === void 0 ? void 0 : valuesWithDisabledDefinitions.length) > 0) {
+    if (valuesWithDisabledDefinitions?.length > 0) {
         logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
     }
     const values = names.map((name) => ({
@@ -101,17 +92,16 @@ const updateValues = (modelType, modelId, identifiers, valuesToUpdate, options =
         updatedAt: new Date(),
         customFieldDefinitionId: fieldDefinitions.find((def) => def.name === name).id,
     }));
-    return Promise.all(values.map((value) => __awaiter(void 0, void 0, void 0, function* () {
-        const [cfv] = yield models_1.CustomFieldValue.upsert(value, {
+    return Promise.all(values.map(async (value) => {
+        const [cfv] = await models_1.CustomFieldValue.upsert(value, {
             transaction: options.transaction,
         });
         return cfv;
-    })));
-});
+    }));
+};
 exports.updateValues = updateValues;
 const deleteValue = (id, options = {}) => models_1.CustomFieldValue.update({ deletedAt: new Date() }, {
     where: { id },
     transaction: options.transaction,
 });
 exports.deleteValue = deleteValue;
-//# sourceMappingURL=value.js.map

package/dist/tests/api/test-api.d.ts

@@ -0,0 +1,2 @@
+declare const app: import("express-serve-static-core").Express;
+export default app;

package/dist/tests/api/test-api.js

@@ -22,45 +22,35 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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 express_1 = __importStar(require("express"));
 const models_1 = require("../../models");
 const app = (0, express_1.default)();
 app.use(express_1.default.json());
 const api = (0, express_1.Router)();
-api.get('/v1/test-models', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
-    const testModels = yield models_1.TestModel.findAll();
+api.get('/v1/test-models', async (req, res) => {
+    const testModels = await models_1.TestModel.findAll();
     return res.json(testModels);
-}));
-api.get('/v1/test-models/:testModelId', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+});
+api.get('/v1/test-models/:testModelId', async (req, res) => {
     const { params: { testModelId } } = req;
-    const testModel = yield models_1.TestModel.findByPk(testModelId);
+    const testModel = await models_1.TestModel.findByPk(testModelId);
     return res.json(testModel);
-}));
-api.post('/v1/test-models', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+});
+api.post('/v1/test-models', async (req, res) => {
     const { body } = req;
-    const testModel = yield models_1.TestModel.create(body);
+    const testModel = await models_1.TestModel.create(body);
     return res.json(testModel);
-}));
-api.patch('/v1/test-models/:testModelId', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+});
+api.patch('/v1/test-models/:testModelId', async (req, res) => {
     const { body, params: { testModelId } } = req;
-    const testModel = yield models_1.TestModel.update(body, {
+    const testModel = await models_1.TestModel.update(body, {
         where: {
             id: testModelId,
         },
         returning: true,
     });
     return res.json(testModel[1][0]);
-}));
+});
 app.use('/api', api);
 exports.default = app;
-//# sourceMappingURL=test-api.js.map

package/dist/tests/helpers/database-config.d.ts

@@ -0,0 +1,15 @@
+declare const _default: {
+    test: {
+        username: string;
+        password: string | null;
+        database: string;
+        host: string;
+        dialect: string;
+        define: {
+            underscored: boolean;
+            underscoredAll: boolean;
+        };
+        logging: boolean;
+    };
+};
+export default _default;

package/dist/tests/helpers/database-config.js

@@ -14,4 +14,3 @@ exports.default = {
         logging: false,
     },
 };
-//# sourceMappingURL=database-config.js.map

package/dist/tests/helpers/index.d.ts

@@ -0,0 +1,2 @@
+export declare const cleanup: () => Promise<void>;
+export declare const getModel: (name: string) => any;

package/dist/tests/helpers/index.js

@@ -1,23 +1,14 @@
 "use strict";
-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 });
 exports.getModel = exports.cleanup = void 0;
 const models_1 = require("../../models");
 // eslint-disable-next-line import/prefer-default-export
-const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
+const cleanup = async () => {
     if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
-        yield models_1.CustomFieldDefinition.unscoped().destroy({ where: {} });
-        yield models_1.TestModel.destroy({ where: {} });
+        await models_1.CustomFieldDefinition.unscoped().destroy({ where: {} });
+        await models_1.TestModel.destroy({ where: {} });
     }
-});
+};
 exports.cleanup = cleanup;
 const getModel = (name) => {
     // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
@@ -25,4 +16,3 @@ const getModel = (name) => {
     return models[name];
 };
 exports.getModel = getModel;
-//# sourceMappingURL=index.js.map

package/dist/tests/mocks/definition.mock.d.ts

@@ -0,0 +1,37 @@
+import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+export declare const coolFieldDefinition: CreateCustomFieldDefinition;
+export declare const coolFieldDefinition2: {
+    name: string;
+    required?: boolean | undefined;
+    disabled?: boolean | undefined;
+    description?: string | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+    deletedAt?: Date | undefined;
+    displayName?: string | undefined;
+    validation?: any;
+    fieldType: string;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+};
+export declare const coolFieldDefinition3: {
+    name: string;
+    required?: boolean | undefined;
+    disabled?: boolean | undefined;
+    description?: string | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+    deletedAt?: Date | undefined;
+    displayName?: string | undefined;
+    validation?: any;
+    fieldType: string;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+};
+export declare const booleanField: (modelType: string) => CreateCustomFieldDefinition;
+export declare const enumField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const rangeField: (modelType: string) => CreateCustomFieldDefinition;
+export declare const createDefinition: (defaults: Partial<CustomFieldDefinitionDTO>) => CreateCustomFieldDefinition;
+export declare const createDefinitions: (defaults: Partial<CustomFieldDefinitionDTO>, length?: number) => CreateCustomFieldDefinition[];