@node-c/data-redis 1.0.0-alpha64 → 1.0.0-beta0

package/src/entityService/redis.entity.service.spec.ts

@@ -0,0 +1,190 @@
+import type { DataFindResults } from '@node-c/core';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  BulkCreateOptions,
+  CreateOptions,
+  DeleteOptions,
+  FindOneOptions,
+  RedisEntityService,
+  UpdateOptions
+} from './index';
+
+import type { RedisRepositoryService } from '../repository';
+import type { RedisStoreService } from '../store';
+
+interface DummyEntity {
+  createdAt?: Date;
+  id: string;
+  updatedAt?: Date;
+  value?: number;
+}
+const entity1: DummyEntity = { createdAt: new Date(), id: '1', updatedAt: new Date(), value: 10 };
+const entity2: DummyEntity = { createdAt: new Date(), id: '2', updatedAt: new Date(), value: 20 };
+
+describe('RedisEntityService', () => {
+  let dummyRepository: Partial<RedisRepositoryService<DummyEntity>>;
+  let dummyStore: Partial<RedisStoreService>;
+  let service: RedisEntityService<DummyEntity>;
+  beforeEach(() => {
+    dummyRepository = {
+      save: vi.fn(),
+      find: vi.fn()
+    };
+    dummyStore = {
+      createTransaction: vi.fn(),
+      endTransaction: vi.fn().mockResolvedValue(undefined)
+    };
+    service = new RedisEntityService(
+      dummyRepository as unknown as RedisRepositoryService<DummyEntity>,
+      dummyStore as unknown as RedisStoreService
+    );
+  });
+
+  describe('bulkCreate', () => {
+    it('returns repository.save result when no options provided', async () => {
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue([entity1, entity2]);
+      const res = await service.bulkCreate([entity1, entity2]);
+      expect(dummyRepository.save).toHaveBeenCalledWith([entity1, entity2], { transactionId: undefined });
+      expect(res).toEqual([entity1, entity2]);
+    });
+    it('returns repository.save result when transactionId provided', async () => {
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue([entity1, entity2]);
+      const opts: BulkCreateOptions = { transactionId: 'tx1' };
+      const res = await service.bulkCreate([entity1, entity2], opts);
+      expect(dummyRepository.save).toHaveBeenCalledWith([entity1, entity2], { transactionId: 'tx1' });
+      expect(res).toEqual([entity1, entity2]);
+    });
+    it('wraps call in transaction when forceTransaction is true and no transactionId', async () => {
+      (dummyStore.createTransaction as ReturnType<typeof vi.fn>).mockReturnValue('tx2');
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue([entity1]);
+      const opts: BulkCreateOptions = { forceTransaction: true };
+      const res = await service.bulkCreate([entity1], opts);
+      expect(dummyStore.createTransaction).toHaveBeenCalled();
+      expect(dummyRepository.save).toHaveBeenCalledWith([entity1], { transactionId: 'tx2' });
+      expect(dummyStore.endTransaction).toHaveBeenCalledWith('tx2');
+      expect(res).toEqual([entity1]);
+    });
+  });
+
+  describe('create', () => {
+    it('returns first element of repository.save when no options are provided', async () => {
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue([entity1]);
+      const res = await service.create(entity1);
+      expect(dummyRepository.save).toHaveBeenCalledWith(entity1, { transactionId: undefined });
+      expect(res).toEqual(entity1);
+    });
+    it('returns first element of repository.save when transactionId provided', async () => {
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue([entity1]);
+      const opts: CreateOptions = { transactionId: 'tx3' };
+      const res = await service.create(entity1, opts);
+      expect(dummyRepository.save).toHaveBeenCalledWith(entity1, { transactionId: 'tx3' });
+      expect(res).toEqual(entity1);
+    });
+    it('wraps call in transaction when forceTransaction is true and no transactionId', async () => {
+      (dummyStore.createTransaction as ReturnType<typeof vi.fn>).mockReturnValue('tx4');
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue([entity1]);
+      const opts: CreateOptions = { forceTransaction: true };
+      const res = await service.create(entity1, opts);
+      expect(dummyStore.createTransaction).toHaveBeenCalled();
+      expect(dummyRepository.save).toHaveBeenCalledWith(entity1, { transactionId: 'tx4' });
+      expect(dummyStore.endTransaction).toHaveBeenCalledWith('tx4');
+      expect(res).toEqual(entity1);
+    });
+  });
+
+  describe('count', () => {
+    it('returns the length of repository.find result', async () => {
+      (dummyRepository.find as ReturnType<typeof vi.fn>).mockResolvedValue([entity1, entity2]);
+      const cnt = await service.count({ filters: {}, findAll: false });
+      expect(dummyRepository.find).toHaveBeenCalledWith({ filters: {}, findAll: false });
+      expect(cnt).toEqual(2);
+    });
+  });
+
+  describe('delete', () => {
+    it('wraps call in transaction when forceTransaction is true and no transactionId', async () => {
+      (dummyStore.createTransaction as ReturnType<typeof vi.fn>).mockReturnValue('tx5');
+      vi.spyOn(service, 'find').mockResolvedValue({ items: [entity1] } as DataFindResults<DummyEntity>);
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue(['key1']);
+      const opts: DeleteOptions = { filters: {}, forceTransaction: true };
+      const res = await service.delete(opts);
+      expect(dummyStore.createTransaction).toHaveBeenCalled();
+      expect(dummyRepository.save).toHaveBeenCalledWith([entity1], { delete: true, transactionId: 'tx5' });
+      expect(dummyStore.endTransaction).toHaveBeenCalledWith('tx5');
+      expect(res).toEqual({ count: 1 });
+    });
+    it('deletes normally when transactionId provided', async () => {
+      vi.spyOn(service, 'find').mockResolvedValue({ items: [entity1, entity2] } as DataFindResults<DummyEntity>);
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue(['k1', 'k2']);
+      const opts: DeleteOptions = { filters: {}, transactionId: 'tx6' };
+      const res = await service.delete(opts);
+      expect(dummyRepository.save).toHaveBeenCalledWith([entity1, entity2], { delete: true, transactionId: 'tx6' });
+      expect(res).toEqual({ count: 2 });
+    });
+  });
+
+  describe('find', () => {
+    it('parses page and perPage and sets "more" flag when items length equals perPage+1', async () => {
+      const items = new Array(11).fill(entity1);
+      (dummyRepository.find as ReturnType<typeof vi.fn>).mockResolvedValue(items);
+      const res = await service.find({ filters: {}, findAll: false, page: 2, perPage: 10 });
+      expect(dummyRepository.find).toHaveBeenCalledWith({ filters: {}, findAll: false, page: 2, perPage: 10 });
+      expect(res.page).toEqual(2);
+      expect(res.perPage).toEqual(10);
+      expect(res.more).toBe(true);
+      expect(res.items.length).toEqual(10);
+    });
+    it('sets perPage to items length when findAll is true', async () => {
+      (dummyRepository.find as ReturnType<typeof vi.fn>).mockResolvedValue([entity1, entity2]);
+      const res = await service.find({ filters: {}, findAll: true });
+      expect(dummyRepository.find).toHaveBeenCalledWith({ filters: {}, findAll: true, page: 1, perPage: 10 });
+      expect(res.perPage).toEqual(2);
+      expect(res.more).toBe(false);
+    });
+  });
+
+  describe('findOne', () => {
+    it('returns the first element when repository.find returns a non-empty array', async () => {
+      const expected = { id: '1', value: 1 } as unknown as DummyEntity;
+      (dummyRepository.find as ReturnType<typeof vi.fn>).mockResolvedValue([expected]);
+      const options: FindOneOptions = { filters: {} };
+      const result = await service.findOne(options);
+      expect(result).toEqual(expected);
+    });
+    it('returns null when repository.find returns an empty array', async () => {
+      (dummyRepository.find as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+      const options: FindOneOptions = { filters: {} };
+      const result = await service.findOne(options);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('update', () => {
+    it('wraps call in transaction when forceTransaction is true and no transactionId', async () => {
+      (dummyStore.createTransaction as ReturnType<typeof vi.fn>).mockReturnValue('tx7');
+      vi.spyOn(service, 'findOne').mockResolvedValue(entity1);
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue([entity2]);
+      const opts: UpdateOptions = { filters: {}, forceTransaction: true };
+      const res = await service.update(entity2, opts);
+      expect(dummyStore.createTransaction).toHaveBeenCalled();
+      expect(dummyRepository.save).toHaveBeenCalledWith(expect.any(Object), { transactionId: 'tx7' });
+      expect(dummyStore.endTransaction).toHaveBeenCalledWith('tx7');
+      expect(res).toEqual({ count: 1, items: [entity2] });
+    });
+    it('returns update result with count 0 when findOne returns null', async () => {
+      vi.spyOn(service, 'findOne').mockResolvedValue(null);
+      const opts: UpdateOptions = { filters: {}, transactionId: 'tx8' };
+      const res = await service.update(entity2, opts);
+      expect(res).toEqual({ count: 0, items: [] });
+    });
+    it('updates normally when findOne returns an item', async () => {
+      vi.spyOn(service, 'findOne').mockResolvedValue(entity1);
+      (dummyRepository.save as ReturnType<typeof vi.fn>).mockResolvedValue([entity2]);
+      const opts: UpdateOptions = { filters: {}, transactionId: 'tx9' };
+      const res = await service.update(entity2, opts);
+      expect(dummyRepository.save).toHaveBeenCalledWith(expect.any(Object), { transactionId: 'tx9' });
+      expect(res).toEqual({ count: 1, items: [entity2] });
+    });
+  });
+});

package/src/entityService/redis.entity.service.ts

@@ -0,0 +1,291 @@
+import {
+  AppConfigCommonDataNoSQLEntityServiceSettings,
+  ApplicationError,
+  ConfigProviderService,
+  DataDeleteResult,
+  DataEntityService,
+  DataFindResults,
+  DataUpdateResult,
+  GenericObject,
+  ProcessObjectAllowedFieldsType
+} from '@node-c/core';
+
+import ld from 'lodash';
+
+import {
+  BulkCreateOptions,
+  BulkCreatePrivateOptions,
+  CountOptions,
+  CountPrivateOptions,
+  CreateOptions,
+  CreatePrivateOptions,
+  DeleteOptions,
+  DeletePrivateOptions,
+  FindOneOptions,
+  FindOnePrivateOptions,
+  FindOptions,
+  FindPrivateOptions,
+  ServiceSaveOptions,
+  UpdateOptions,
+  UpdatePrivateOptions
+} from './redis.entity.service.definitions';
+
+import { RedisRepositoryService } from '../repository';
+import { RedisStoreService } from '../store';
+
+// TODO: support "pseudo-relations"
+// TODO: support update of multiple items in the update method
+export class RedisEntityService<Entity extends object> extends DataEntityService<Entity> {
+  protected settings: AppConfigCommonDataNoSQLEntityServiceSettings;
+
+  constructor(
+    // eslint-disable-next-line no-unused-vars
+    protected configProvider: ConfigProviderService,
+    // eslint-disable-next-line no-unused-vars
+    protected repository: RedisRepositoryService<Entity>,
+    // eslint-disable-next-line no-unused-vars
+    protected store: RedisStoreService
+  ) {
+    super(configProvider, repository.dataModuleName);
+  }
+
+  async bulkCreate(
+    data: Partial<Entity>[],
+    options?: BulkCreateOptions,
+    privateOptions?: BulkCreatePrivateOptions
+  ): Promise<Entity[]> {
+    const { store } = this;
+    const actualOptions = options || {};
+    const actualPrivateOptions = privateOptions || {};
+    const { forceTransaction, transactionId } = actualOptions;
+    if (!transactionId && forceTransaction) {
+      const tId = store.createTransaction();
+      const result = await this.bulkCreate(data, { ...actualOptions, transactionId: tId }, actualPrivateOptions);
+      await store.endTransaction(tId);
+      return result;
+    }
+    const { processInputAllowedFieldsEnabled, validate } = actualPrivateOptions;
+    return await this.save(data, {
+      generatePrimaryKeys: true,
+      processObjectAllowedFieldsEnabled: processInputAllowedFieldsEnabled,
+      transactionId,
+      validate
+    });
+  }
+
+  async count(options: CountOptions, privateOptions?: CountPrivateOptions): Promise<number | undefined> {
+    const { repository } = this;
+    const { filters, findAll } = options;
+    const { allowCountWithoutFilters, processFiltersAllowedFieldsEnabled } = privateOptions || {};
+    const parsedFilters = (await this.processObjectAllowedFields<GenericObject>(filters || {}, {
+      allowedFields: repository.columnNames,
+      isEnabled: processFiltersAllowedFieldsEnabled,
+      objectType: ProcessObjectAllowedFieldsType.Filters
+    })) as GenericObject;
+    if (!allowCountWithoutFilters && !Object.keys(parsedFilters).length) {
+      throw new ApplicationError('At least one filter field for counting is required.');
+    }
+    return (await repository.find({ filters: parsedFilters, findAll, individualSearch: false })).items.length;
+  }
+
+  async create(data: Partial<Entity>, options?: CreateOptions, privateOptions?: CreatePrivateOptions): Promise<Entity> {
+    const { store } = this;
+    const actualOptions = options || {};
+    const actualPrivateOptions = privateOptions || {};
+    const { forceTransaction, transactionId } = actualOptions;
+    if (!transactionId && forceTransaction) {
+      const tId = store.createTransaction();
+      const result = await this.create(data, { ...actualOptions, transactionId: tId }, actualPrivateOptions);
+      await store.endTransaction(tId);
+      return result;
+    }
+    const { processInputAllowedFieldsEnabled, validate } = actualPrivateOptions;
+    return await this.save<Partial<Entity>, Entity>(data instanceof Array ? data[0] : data, {
+      generatePrimaryKeys: false,
+      processObjectAllowedFieldsEnabled: processInputAllowedFieldsEnabled,
+      transactionId,
+      validate
+    });
+  }
+
+  async delete(options: DeleteOptions, privateOptions?: DeletePrivateOptions): Promise<DataDeleteResult<Entity>> {
+    const { repository, store } = this;
+    const { filters, forceTransaction, returnOriginalItems, transactionId } = options;
+    const actualPrivateOptions = privateOptions || {};
+    if (!transactionId && forceTransaction) {
+      const tId = store.createTransaction();
+      const result = await this.delete({ ...options, transactionId: tId }, actualPrivateOptions);
+      await store.endTransaction(tId);
+      return result;
+    }
+    const { processFiltersAllowedFieldsEnabled, requirePrimaryKeys = true } = actualPrivateOptions;
+    const parsedFilters = (await this.processObjectAllowedFields<GenericObject>(filters, {
+      allowedFields: repository.columnNames,
+      isEnabled: processFiltersAllowedFieldsEnabled,
+      objectType: ProcessObjectAllowedFieldsType.Filters
+    })) as GenericObject;
+    if (!Object.keys(parsedFilters).length) {
+      throw new ApplicationError('At least one filter field for deleting data is required.');
+    }
+    const { items: itemsToDelete } = await this.find({ filters, findAll: true }, { requirePrimaryKeys });
+    const results: string[] = await this.save(itemsToDelete, {
+      delete: true,
+      generatePrimaryKeys: false,
+      transactionId
+    });
+    const dataToReturn: DataDeleteResult<Entity> = { count: results.length };
+    if (returnOriginalItems) {
+      dataToReturn.originalItems = itemsToDelete;
+    }
+    return dataToReturn;
+  }
+
+  async find(options: FindOptions, privateOptions?: FindPrivateOptions): Promise<DataFindResults<Entity>> {
+    const { repository } = this;
+    const {
+      filters,
+      getTotalCount = true,
+      individualSearch,
+      page: optPage,
+      perPage: optPerPage,
+      findAll: optFindAll
+    } = options;
+    const { processFiltersAllowedFieldsEnabled, requirePrimaryKeys } = privateOptions || {};
+    // make sure it's truly a number - it could come as string from GET requests
+    const page = optPage ? parseInt(optPage as unknown as string, 10) : 1;
+    // same as above - must be a number
+    const perPage = optPerPage ? parseInt(optPerPage as unknown as string, 10) : 10;
+    const findAll = optFindAll === true || (optFindAll as unknown) === 'true';
+    const findResults: DataFindResults<Entity> = { page: 1, perPage: 0, items: [], more: false };
+    const parsedFilters = (await this.processObjectAllowedFields<GenericObject>(filters || {}, {
+      allowedFields: repository.columnNames,
+      isEnabled: processFiltersAllowedFieldsEnabled,
+      objectType: ProcessObjectAllowedFieldsType.Filters
+    })) as GenericObject;
+    if (!findAll) {
+      findResults.page = page;
+      findResults.perPage = perPage;
+    }
+    const { items, more } = await repository.find(
+      { filters: parsedFilters, findAll, individualSearch, page, perPage },
+      { requirePrimaryKeys }
+    );
+    if (findAll) {
+      findResults.perPage = items.length;
+    } else {
+      findResults.more = more;
+      if (getTotalCount) {
+        findResults.totalCount = await this.count(options, { allowCountWithoutFilters: true });
+      }
+    }
+    findResults.items = items;
+    return findResults;
+  }
+
+  async findOne(options: FindOneOptions, privateOptions?: FindOnePrivateOptions): Promise<Entity | null> {
+    const { filters } = options;
+    const { processFiltersAllowedFieldsEnabled, requirePrimaryKeys } = privateOptions || {};
+    const parsedFilters = (await this.processObjectAllowedFields<GenericObject>(filters, {
+      allowedFields: this.repository.columnNames,
+      isEnabled: processFiltersAllowedFieldsEnabled,
+      objectType: ProcessObjectAllowedFieldsType.Filters
+    })) as GenericObject;
+    if (!Object.keys(parsedFilters).length) {
+      throw new ApplicationError('At least one filter field is required for the findOne method.');
+    }
+    const result = await this.repository.find(
+      { filters, individualSearch: true, page: 1, perPage: 1 },
+      { requirePrimaryKeys }
+    );
+    return result.items[0] || null;
+  }
+
+  protected async save<Data extends Partial<Entity> | Partial<Entity>[], ReturnData = unknown>(
+    data: Data,
+    options: ServiceSaveOptions
+  ): Promise<ReturnData> {
+    const { repository, settings } = this;
+    const { validationSettings } = settings;
+    const {
+      delete: optDelete,
+      generatePrimaryKeys,
+      processObjectAllowedFieldsEnabled,
+      transactionId,
+      validate
+    } = options || {};
+    if (optDelete) {
+      return (await repository.save(data as unknown as Entity, {
+        delete: true,
+        generatePrimaryKeys: false,
+        transactionId,
+        validate: false
+      })) as ReturnData;
+    }
+    const dataToSave: Data | Data[] = await this.processObjectAllowedFields<Data>(data, {
+      allowedFields: repository.columnNames,
+      isEnabled: processObjectAllowedFieldsEnabled,
+      objectType: ProcessObjectAllowedFieldsType.Input
+    });
+    return (await repository.save(dataToSave as Entity, {
+      generatePrimaryKeys,
+      transactionId,
+      validate: typeof validate !== 'undefined' ? validate : !!validationSettings?.isEnabled
+    })) as ReturnData;
+  }
+
+  // TODO: reduce to need to double 2 finds (one here and one in the repository's save method)
+  // by refactoring both methods
+  async update(
+    data: Entity,
+    options: UpdateOptions,
+    privateOptions?: UpdatePrivateOptions
+  ): Promise<DataUpdateResult<Entity>> {
+    const { store } = this;
+    const { filters, forceTransaction, returnData, returnOriginalItems, transactionId } = options;
+    const actualPrivateOptions = privateOptions || {};
+    if (!transactionId && forceTransaction) {
+      const tId = store.createTransaction();
+      const result = await this.update(data, { ...options, transactionId: tId }, actualPrivateOptions);
+      await store.endTransaction(tId);
+      return result;
+    }
+    const {
+      processFiltersAllowedFieldsEnabled,
+      processInputAllowedFieldsEnabled,
+      requirePrimaryKeys = true,
+      validate
+    } = actualPrivateOptions;
+    const dataToReturn: DataUpdateResult<Entity> = {};
+    const { items: itemsToUpdate } = await this.find(
+      { filters, findAll: true },
+      { processFiltersAllowedFieldsEnabled, requirePrimaryKeys }
+    );
+    if (!itemsToUpdate.length) {
+      dataToReturn.count = 0;
+      if (returnData) {
+        dataToReturn.items = [];
+      }
+      if (returnOriginalItems) {
+        dataToReturn.originalItems = [];
+      }
+      return dataToReturn;
+    }
+    const updateResult = await this.save<Entity[], Entity[]>(
+      itemsToUpdate.map(item => ld.merge(item, data)),
+      {
+        generatePrimaryKeys: false,
+        processObjectAllowedFieldsEnabled: processInputAllowedFieldsEnabled,
+        transactionId,
+        validate
+      }
+    );
+    dataToReturn.count = updateResult.length;
+    if (returnData) {
+      dataToReturn.items = updateResult;
+    }
+    if (returnOriginalItems) {
+      dataToReturn.originalItems = itemsToUpdate;
+    }
+    return dataToReturn;
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './common/definitions';
+export * from './entityService';
+export * from './module';
+export * from './repository';
+export * from './store';

package/src/module/index.ts

@@ -0,0 +1,2 @@
+export * from './redis.module.definitions';
+export * from './redis.module';

package/src/module/redis.module.definitions.ts

@@ -0,0 +1,18 @@
+import { ModuleMetadata } from '@nestjs/common';
+
+import { GenericObject } from '@node-c/core';
+
+export interface RedisModuleOptions {
+  entityModuleRegisterOptions?: unknown;
+  exports?: ModuleMetadata['exports'];
+  folderData: GenericObject<unknown>;
+  imports?: {
+    atEnd?: ModuleMetadata['imports'];
+    postStore?: ModuleMetadata['imports'];
+    preStore?: ModuleMetadata['imports'];
+  };
+  moduleClass: unknown;
+  moduleName: string;
+  providers?: ModuleMetadata['providers'];
+  registerOptionsPerEntityModule?: GenericObject;
+}

package/src/module/redis.module.spec.ts

@@ -0,0 +1,80 @@
+import { loadDynamicModules } from '@node-c/core';
+import { Mock, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { RedisModule, RedisModuleOptions } from './index';
+
+import { RedisStoreModule } from '../store';
+
+vi.mock('@node-c/core', () => ({
+  loadDynamicModules: vi.fn()
+}));
+vi.mock('../store', () => ({
+  RedisStoreModule: {
+    register: vi.fn()
+  }
+}));
+
+describe('RedisModule', () => {
+  describe('register', () => {
+    const dummyModules = ['moduleA', 'moduleB'];
+    const dummyStoreDynamic = { module: 'StoreModule', global: false };
+    const dummyModuleClass = class TestModule {};
+    beforeEach(() => {
+      (loadDynamicModules as unknown as Mock).mockReturnValue({ modules: dummyModules });
+      (RedisStoreModule.register as unknown as Mock).mockReturnValue(dummyStoreDynamic);
+    });
+    it('should return dynamic module with all additionalImports and options provided', () => {
+      const additionalImports = {
+        preStore: ['pre1', 'pre2'],
+        postStore: ['post1'],
+        atEnd: ['end1']
+      };
+      const options = {
+        folderData: 'dummyFolder',
+        imports: additionalImports,
+        moduleClass: dummyModuleClass,
+        moduleName: 'testModule',
+        storeKey: 'store123',
+        providers: ['prov1'],
+        exports: ['exp1']
+      } as unknown as RedisModuleOptions;
+      const result = RedisModule.register(options);
+      expect(result.global).toBe(true);
+      expect(result.module).toBe(dummyModuleClass);
+      expect(result.imports).toEqual([
+        ...additionalImports.preStore,
+        dummyStoreDynamic,
+        ...additionalImports.postStore,
+        ...dummyModules,
+        ...additionalImports.atEnd
+      ]);
+      expect(result.providers).toEqual(['prov1']);
+      expect(result.exports).toEqual([...dummyModules, 'exp1']);
+      expect(RedisStoreModule.register).toHaveBeenCalledWith({
+        dataModuleName: options.moduleName
+      });
+      expect(loadDynamicModules).toHaveBeenCalledWith(options.folderData);
+    });
+    it('should return dynamic module when additionalImports, providers, and exports are undefined', () => {
+      const options = {
+        folderData: 'dummyFolder',
+        moduleClass: dummyModuleClass,
+        moduleName: 'testModule',
+        storeKey: 'store123'
+      } as unknown as RedisModuleOptions;
+      (loadDynamicModules as unknown as Mock).mockReturnValue({ modules: undefined });
+      const result = RedisModule.register(options);
+      expect(result.global).toBe(true);
+      expect(result.module).toBe(dummyModuleClass);
+      expect(result.imports).toEqual([
+        ...(undefined || []),
+        dummyStoreDynamic,
+        ...(undefined || []),
+        ...(undefined || []),
+        ...(undefined || [])
+      ]);
+      expect(result.providers).toEqual([]);
+      expect(result.exports).toEqual([...(undefined || []), ...(undefined || [])]);
+    });
+  });
+});

package/src/module/redis.module.ts

@@ -0,0 +1,31 @@
+import { DynamicModule } from '@nestjs/common';
+
+import { loadDynamicModules } from '@node-c/core';
+
+import { RedisModuleOptions } from './redis.module.definitions';
+
+import { RedisStoreModule } from '../store';
+
+export class RedisModule {
+  static register(options: RedisModuleOptions): DynamicModule {
+    const { folderData, imports: additionalImports, moduleClass, moduleName } = options;
+    const { atEnd: importsAtEnd, postStore: importsPostStore, preStore: importsPreStore } = additionalImports || {};
+    const { modules } = loadDynamicModules(folderData, {
+      moduleRegisterOptions: options.entityModuleRegisterOptions,
+      registerOptionsPerModule: options.registerOptionsPerEntityModule
+    });
+    return {
+      global: true,
+      module: moduleClass as DynamicModule['module'],
+      imports: [
+        ...(importsPreStore || []),
+        RedisStoreModule.register({ dataModuleName: moduleName }),
+        ...(importsPostStore || []),
+        ...(modules || []),
+        ...(importsAtEnd || [])
+      ],
+      providers: [...(options.providers || [])],
+      exports: [...(modules || []), ...(options.exports || [])]
+    };
+  }
+}

package/src/repository/index.ts

@@ -0,0 +1,3 @@
+export * from './redis.repository.definitions';
+export * from './redis.repository.module';
+export * from './redis.repository.service';