@autofleet/sadot 0.5.4-beta.26 → 0.5.4-beta.4

package/src/hooks/enrich.ts

@@ -4,8 +4,6 @@ import * as DefinitionRepo from '../repository/definition';
 import CustomFieldValue from '../models/CustomFieldValue';
 import CustomFieldDefinition from '../models/CustomFieldDefinition';
 import { SerializedCustomFields } from '../types/definition';
-import { ModelOptions } from '../types';
-import applyScopeToInstance from '../utils/scopeAttributes';
 
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
 
@@ -32,7 +30,6 @@ const enrichResults = (
   modelType: string,
   scopeAttributes: string[],
   hookType?: SupportedHookTypes,
-  modelOptions: ModelOptions = {},
 ) => async (
   instancesOrInstance: any | any[],
   options,
@@ -51,33 +48,21 @@ const enrichResults = (
 
   instances = instances.filter(Boolean);
 
-  const identifiers = applyScopeToInstance(instances, scopeAttributes);
+  const identifiers = instances.map((instance) =>
+    scopeAttributes
+      .map((attr) => instance[attr])).flat();
 
   const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
-
   const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
     ...map,
     [identifier]: [],
-
   }), {});
-
   const customFieldDefinitions = await DefinitionRepo.findByEntityIds(
     modelType,
     uniqueIdentifiers,
-    { transaction: options.transaction, modelOptions },
+    { transaction: options.transaction },
   );
 
-  if (modelOptions?.include && modelOptions.useEntityIdFromInclude) {
-    // if we pass useEntityIdFromInclude,
-    //  map the entity from the options to the identifierCustomFieldDefinitionsMapping
-    modelOptions.include(identifiers).forEach(({ model }) => {
-      customFieldDefinitions.forEach((cfd) => {
-        const entityId = cfd[`${model.name}.entityId`];
-        identifierCustomFieldDefinitionsMapping[entityId] = [];
-      });
-    });
-  }
-
   const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({
     ...map,
     [definition.id]: definition,
@@ -119,7 +104,6 @@ const enrichResults = (
 
     scopeAttributes.forEach((attribute) => {
       const identifier = instance[attribute];
-
       const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];
       if (entityCustomFieldDefinitions?.length > 0) {
         entityCustomFieldDefinitions.forEach((customFieldDefinition) => {

package/src/hooks/update.ts

@@ -1,7 +1,5 @@
 import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
-import { ModelOptions } from '../types';
-import applyScopeToInstance from '../utils/scopeAttributes';
 
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
@@ -16,14 +14,14 @@ export const beforeBulkUpdate = (options): void => {
  * A hook to update the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export const beforeUpdate = (scopeAttributes: string[], modelOptions: ModelOptions = {}) => async (
+export const beforeUpdate = (scopeAttributes: string[]) => async (
   instance,
   options,
 ): Promise<void> => {
   logger.debug('sadot - before update hook');
   const { fields } = options;
   const modelType = instance.constructor.name;
-  const identifiers = applyScopeToInstance(instance, scopeAttributes);
+  const identifiers = scopeAttributes.map((attribute) => instance[attribute]);
 
   const customFieldsIdx = fields.indexOf('customFields');
   if (customFieldsIdx > -1) {
@@ -33,8 +31,7 @@ export const beforeUpdate = (scopeAttributes: string[], modelOptions: ModelOptio
       instance.id,
       identifiers,
       customFields,
-      { transaction: options.transaction, modelOptions },
-
+      { transaction: options.transaction },
     );
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);

package/src/index.ts

@@ -7,9 +7,7 @@ import api from './api';
 import initDB from './utils/db';
 import logger from './utils/logger';
 import type { CustomFieldOptions, ModelFetcher } from './types';
-import {
-  addHooks, addScopes, applyCustomAssociation, removeHooks,
-} from './utils/init';
+import { addHooks, addScopes, removeHooks } from './utils/init';
 
 export * from './utils/validations/custom-fields';
 
@@ -26,7 +24,7 @@ const useCustomFields = async (
 ): Promise<Sequelize> => {
   const { models } = options;
   if (app) {
-    app.use('/api', api);
+    app.use('/api', options.middleware, api);
   }
   const sequelize = initDB(options.databaseConfig);
   if (process.env.NODE_ENV === 'test') {
@@ -36,7 +34,6 @@ const useCustomFields = async (
   addHooks(models, getModel);
   await initTables(sequelize, options.getUser);
   addScopes(models, getModel);
-  applyCustomAssociation(models);
   logger.debug('sadot - custom fields finished initializing with models', models);
   return sequelize;
 };

package/src/models/index.ts

@@ -5,12 +5,10 @@ import logger from '../utils/logger';
 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';
 
 const productionModels = [CustomFieldDefinition, CustomFieldValue];
-const testModels = [TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel];
+const testModels = [TestModel, AssociatedTestModel];
 
 const SADOT_MIGRATION_PREFIX = 'sadot-migration';
 const SCHEMA_VERSION = 1;
@@ -90,8 +88,6 @@ const initTestModels = async (sequelize: Sequelize): Promise<void> => {
   logger.info('custom-fields: test models added');
   await TestModel.sync({ alter: true });
   await AssociatedTestModel.sync({ alter: true });
-  await ContextTestModel.sync({ alter: true });
-  await ContextAwareTestModel.sync({ alter: true });
   logger.info('custom-fields: test models synced');
 };
 
@@ -100,8 +96,6 @@ export {
   CustomFieldDefinition,
   TestModel,
   AssociatedTestModel,
-  ContextAwareTestModel,
-  ContextTestModel,
   initTables,
   initTestModels,
 };

package/src/repository/definition.ts

@@ -1,27 +1,21 @@
-import {
-  FindOptions,
-  Op, WhereOptions,
-} from 'sequelize';
+import { Op, WhereOptions } from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
-import { ModelOptions } from '../types';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
 
 export const findAll = (
-  where: WhereOptions,
+  where: any,
   options: any = { withDisabled: false },
 ): Promise<CustomFieldDefinition[]> => {
   const queryModel = options.withDisabled
     ? CustomFieldDefinition.unscoped()
     : CustomFieldDefinition;
-
   return queryModel.scope('userScope').findAll({
     where,
     transaction: options.transaction,
     raw: true,
-    include: options.include,
   });
 };
 
@@ -41,26 +35,26 @@ export const findById = (
   return CustomFieldDefinition.scope('userScope').findByPk(id);
 };
 
+export const findByEntityId = async (
+  entityId: string,
+  options: any = {},
+): Promise<CustomFieldDefinition[]> => CustomFieldDefinition.findAll({
+  where: { entityId },
+  transaction: options.transaction,
+});
+
 export const findByEntityIds = async (
   modelType: string,
   entityIds: string[],
-  options: FindOptions & { modelOptions?: ModelOptions } = {},
-): Promise<CustomFieldDefinition[]> => {
-  const { include, useEntityIdFromInclude } = options.modelOptions;
-  const where: WhereOptions = {
+  options: any = {},
+): Promise<CustomFieldDefinition[]> => CustomFieldDefinition.findAll({
+  where: {
     modelType,
-  };
-
-  if (!useEntityIdFromInclude) {
-    where.entityId = entityIds;
-  }
-  return CustomFieldDefinition.findAll({
-    where,
-    transaction: options.transaction,
-    include: include?.(entityIds),
-    raw: true,
-  });
-};
+    entityId: entityIds,
+  },
+  transaction: options.transaction,
+  raw: true,
+});
 
 export const findByWhere = (where): Promise<CustomFieldDefinition | null> =>
   CustomFieldDefinition.scope('userScope').findOne({
@@ -106,23 +100,10 @@ export const getRequiredFields = async (
   modelType: string,
   modelId: string | string[],
   entityId: string | string[],
-  modelOptions: ModelOptions = {},
 ): Promise<string[]> => {
   const entityIds = Array.isArray(entityId) ? entityId : [entityId];
-  const { include, useEntityIdFromInclude } = modelOptions;
-
-  const where: WhereOptions = {
-    modelType,
-    required: true,
-  };
-
-  if (!useEntityIdFromInclude) {
-    where.entityId = entityIds;
-  }
-
   const requiredFields = await CustomFieldDefinition.findAll({
-    where,
-    include: include?.(entityIds),
+    where: { required: true, modelType, entityId: { [Op.in]: entityIds } },
     logging: true,
   });
   const requiredFieldsNames = requiredFields.map((definition) => definition.name);

package/src/repository/value.ts

@@ -1,11 +1,9 @@
 /* eslint-disable max-len */
-import type { FindOptions, WhereOptions } from 'sequelize';
 import { CustomFieldValue, CustomFieldDefinition } from '../models';
 import * as DefinitionRepo from './definition';
 import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
 import logger from '../utils/logger';
 import { MissingDefinitionError } from '../errors';
-import { ModelOptions } from '../types';
 
 export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
   CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });
@@ -52,27 +50,18 @@ export const updateValues = async (
   modelId: string,
   identifiers: string[],
   valuesToUpdate: ValuesToUpdate,
-  options: FindOptions & { modelOptions?: ModelOptions } = {},
+  options: any = {},
 ): Promise<CustomFieldValue[]> => {
-  const names = Object.keys(valuesToUpdate);
-  logger.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
-    names, options, valuesToUpdate, identifiers,
-  });
-  const { modelOptions, transaction } = options;
+  logger.info(`custom-fields: updating values for ${modelType} ${modelId}`, { valuesToUpdate });
 
-  const where: WhereOptions = {
-    modelType,
-    name: names,
-  };
-
-  if (!options.modelOptions?.useEntityIdFromInclude) {
-    where.entityId = identifiers;
-  }
-  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) || [];
+  const names = Object.keys(valuesToUpdate);
+  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) {
-    logger.info(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
     const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
     throw new MissingDefinitionError(missingDefinitions);
   }

package/src/tests/helpers/database-config.ts

@@ -4,7 +4,6 @@ export default {
     password: process.env.DB_PASSWORD || null,
     database: process.env.DB_NAME || 'sadot_package_test',
     host: process.env.DB_HOST || '127.0.0.1',
-    port: process.env.DB_PORT || 5432,
     dialect: process.env.DB_TYPE || 'postgres',
     define: {
       underscored: true,

package/src/tests/helpers/index.ts

@@ -1,14 +1,10 @@
-import {
-  ContextAwareTestModel, ContextTestModel, CustomFieldDefinition, TestModel,
-} from '../../models';
+import { CustomFieldDefinition, TestModel } from '../../models';
 
 // eslint-disable-next-line import/prefer-default-export
 export const cleanup = async (): Promise<void> => {
   if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
     await CustomFieldDefinition.unscoped().destroy({ where: {} });
     await TestModel.destroy({ where: {} });
-    await ContextAwareTestModel.destroy({ where: {} });
-    await ContextTestModel.destroy({ where: {} });
   }
 };
 

package/src/tests/mocks/definition.mock.ts

@@ -1,13 +1,6 @@
 import { v4 as uuidv4 } from 'uuid';
 import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
 
-export const contextAwareFieldDefinition = {
-  name: 'cool field',
-  modelType: 'ContextAwareTestModel',
-  fieldType: 'number',
-  entityType: 'fleetId',
-};
-
 export const coolFieldDefinition: CreateCustomFieldDefinition = {
   name: 'cool field',
   modelType: 'TestModel',

package/src/types/index.ts

@@ -1,35 +1,18 @@
-import { IncludeOptions } from 'sequelize';
-import { ModelCtor } from 'sequelize-typescript';
+import { RequestHandler } from 'express';
 
 export type ModelFetcher = (name: string) => any;
 
 export type ModelOptions = {
-  /**
-   * Include options for the model
-   */
-  include?: (entityIds: string[]) => IncludeOptions[];
-  /**
-    * Custom association for the model
-    * @param model - The model to associate with
-   */
-
-  customAssociation?: (model: ModelCtor) => void;
-  /**
-   * Whether to use the entity id  from the instance per scope attribute
-   */
-  useEntityIdFromInclude?: boolean
-}
-export type Models = {
   name: string;
-  scopeAttributes: any[];
-  modelOptions?: ModelOptions;
+  scopeAttributes: string[];
   creationWebhookHandler?: (instance: any) => any;
   updateWebhookHandler?: (instance: any) => any;
   deletionWebhookHandler?: (instance: any) => any;
 }
 
 export type CustomFieldOptions = {
-  models: Models[];
+  models: ModelOptions[];
   databaseConfig: any;
   getUser: () => any;
+  middleware?: RequestHandler
 };

package/src/utils/init.ts

@@ -2,7 +2,6 @@ import { DataTypes } from 'sequelize';
 import { ModelCtor } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
 import {
-  CustomFieldDefinition,
   CustomFieldValue,
 } from '../models';
 import {
@@ -15,14 +14,12 @@ import {
 } from '../hooks';
 import { customFieldsFilterScope } from '../scopes';
 import logger from './logger';
-import type { ModelFetcher, Models } from '../types';
+import type { ModelFetcher, ModelOptions } from '../types';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
 
-export const addHooks = (models: Models[], getModel: ModelFetcher): void => {
-  models.forEach(async ({
-    name, scopeAttributes, modelOptions,
-  }) => {
+export const addHooks = (models: ModelOptions[], getModel: ModelFetcher): void => {
+  models.forEach(async ({ name, scopeAttributes }) => {
     try {
       const model = getModel(name);
       if (!model) {
@@ -41,18 +38,18 @@ export const addHooks = (models: Models[], getModel: ModelFetcher): void => {
       model.addHook('beforeFind', 'sadot-beforeFind', beforeFind(scopeAttributes));
       model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', beforeBulkCreate);
       model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', beforeBulkUpdate);
-      model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes, modelOptions));
-      model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes, modelOptions));
-      model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes, 'afterFind', modelOptions));
-      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes, null, modelOptions));
-      model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes, null, modelOptions));
+      model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes));
+      model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes));
+      model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes, 'afterFind'));
+      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes));
+      model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes));
     } catch (e) {
       logger.error(`Could not add custom fields hook to model ${name}. `, e);
     }
   });
 };
 
-export const removeHooks = (models: Models[], getModel: ModelFetcher): void => {
+export const removeHooks = (models: ModelOptions[], getModel: ModelFetcher): void => {
   models.forEach(async ({ name }) => {
     try {
       const model = getModel(name);
@@ -84,7 +81,7 @@ const addAssociations = (model: ModelCtor, modelName: string): void => {
   CustomFieldValue.belongsTo(model, { foreignKey: 'modelId', as: modelName });
 };
 
-export const addScopes = (models: Models[], getModel: ModelFetcher): void => {
+export const addScopes = (models: ModelOptions[], getModel: ModelFetcher): void => {
   models.forEach(async ({ name, scopeAttributes }) => {
     try {
       const model = getModel(name);
@@ -104,9 +101,3 @@ export const addScopes = (models: Models[], getModel: ModelFetcher): void => {
     }
   });
 };
-
-export const applyCustomAssociation = (models: Models[]): void => {
-  models.forEach(({ modelOptions }) => {
-    modelOptions?.customAssociation?.(CustomFieldDefinition);
-  });
-};

package/dist/models/tests/contextAwareModels/ContextAwareTestModel.d.ts

@@ -1,10 +0,0 @@
-import { Model } from 'sequelize-typescript';
-import ContextTestModel from './ContextTestModel';
-declare class ContextAwareTestModel extends Model {
-    id: string;
-    contextId: string;
-    coolAttribute?: boolean;
-    customFields?: any;
-    context: ContextTestModel;
-}
-export default ContextAwareTestModel;

package/dist/models/tests/contextAwareModels/ContextAwareTestModel.js

@@ -1,55 +0,0 @@
-"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);
-};
-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 */
-const sequelize_typescript_1 = require("sequelize-typescript");
-const ContextTestModel_1 = __importDefault(require("./ContextTestModel"));
-let ContextAwareTestModel = class ContextAwareTestModel extends sequelize_typescript_1.Model {
-};
-__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)
-], ContextAwareTestModel.prototype, "id", void 0);
-__decorate([
-    (0, sequelize_typescript_1.ForeignKey)(() => ContextTestModel_1.default),
-    (0, sequelize_typescript_1.Column)({
-        type: sequelize_typescript_1.DataType.UUID,
-    }),
-    __metadata("design:type", String)
-], ContextAwareTestModel.prototype, "contextId", void 0);
-__decorate([
-    (0, sequelize_typescript_1.Column)({
-        type: sequelize_typescript_1.DataType.BOOLEAN,
-    }),
-    __metadata("design:type", Boolean)
-], ContextAwareTestModel.prototype, "coolAttribute", void 0);
-__decorate([
-    (0, sequelize_typescript_1.Column)({
-        type: sequelize_typescript_1.DataType.VIRTUAL,
-    }),
-    __metadata("design:type", Object)
-], ContextAwareTestModel.prototype, "customFields", void 0);
-__decorate([
-    (0, sequelize_typescript_1.BelongsTo)(() => ContextTestModel_1.default),
-    __metadata("design:type", ContextTestModel_1.default)
-], ContextAwareTestModel.prototype, "context", void 0);
-ContextAwareTestModel = __decorate([
-    (0, sequelize_typescript_1.Table)({ createdAt: false, updatedAt: false })
-], ContextAwareTestModel);
-exports.default = ContextAwareTestModel;

package/dist/models/tests/contextAwareModels/ContextTestModel.d.ts

@@ -1,13 +0,0 @@
-import { Model } from 'sequelize-typescript';
-declare enum EEntityTypes {
-    BUSINESS_MODEL = "businessModel",
-    CONTEXT = "context",
-    DEMAND_SOURCE = "demandSource",
-    FLEET = "fleet"
-}
-declare class ContextTestModel extends Model {
-    id: string;
-    entityId: string;
-    entityType: EEntityTypes;
-}
-export default ContextTestModel;

package/dist/models/tests/contextAwareModels/ContextTestModel.js

@@ -1,47 +0,0 @@
-"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 */
-const sequelize_typescript_1 = require("sequelize-typescript");
-// eslint-disable-next-line no-shadow
-var EEntityTypes;
-(function (EEntityTypes) {
-    EEntityTypes["BUSINESS_MODEL"] = "businessModel";
-    EEntityTypes["CONTEXT"] = "context";
-    EEntityTypes["DEMAND_SOURCE"] = "demandSource";
-    EEntityTypes["FLEET"] = "fleet";
-})(EEntityTypes || (EEntityTypes = {}));
-let ContextTestModel = class ContextTestModel extends sequelize_typescript_1.Model {
-};
-__decorate([
-    sequelize_typescript_1.PrimaryKey,
-    (0, sequelize_typescript_1.Column)({
-        defaultValue: sequelize_typescript_1.DataType.UUIDV4,
-        type: sequelize_typescript_1.DataType.UUID,
-    }),
-    __metadata("design:type", String)
-], ContextTestModel.prototype, "id", void 0);
-__decorate([
-    (0, sequelize_typescript_1.Column)({
-        type: sequelize_typescript_1.DataType.UUID,
-    }),
-    __metadata("design:type", String)
-], ContextTestModel.prototype, "entityId", void 0);
-__decorate([
-    (0, sequelize_typescript_1.Column)({
-        type: sequelize_typescript_1.DataType.ENUM(...Object.values(EEntityTypes)),
-    }),
-    __metadata("design:type", String)
-], ContextTestModel.prototype, "entityType", void 0);
-ContextTestModel = __decorate([
-    (0, sequelize_typescript_1.Table)({ createdAt: false, updatedAt: false })
-], ContextTestModel);
-exports.default = ContextTestModel;

package/dist/utils/scopeAttributes.d.ts

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

package/dist/utils/scopeAttributes.js

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

package/src/models/tests/contextAwareModels/ContextAwareTestModel.ts

@@ -1,45 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import {
-  Table,
-  Column,
-  Model,
-  PrimaryKey,
-  DataType,
-  HasMany,
-  BelongsTo,
-  ForeignKey,
-} from 'sequelize-typescript';
-import AssociatedTestModel from '../AssociatedTestModel';
-import ContextTestModel from './ContextTestModel';
-
-@Table({ createdAt: false, updatedAt: false })
-class ContextAwareTestModel extends Model {
-    @PrimaryKey
-    @Column({
-      type: DataType.UUID,
-      defaultValue: DataType.UUIDV4,
-      allowNull: false,
-    })
-    id!: string;
-
-  @ForeignKey(() => ContextTestModel)
-    @Column({
-      type: DataType.UUID,
-    })
-      contextId: string;
-
-    @Column({
-      type: DataType.BOOLEAN,
-    })
-    coolAttribute?: boolean;
-
-    @Column({
-      type: DataType.VIRTUAL,
-    })
-    customFields?: any;
-
-  @BelongsTo(() => ContextTestModel)
-  context: ContextTestModel;
-}
-
-export default ContextAwareTestModel;