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

package/src/repository/redis.repository.definitions.ts

@@ -0,0 +1,97 @@
+import { GenericObject } from '@node-c/core';
+
+import { ValidationSchema } from 'class-validator';
+
+export interface EntitySchema {
+  columns: {
+    [columnName: string]: {
+      generated?: boolean;
+      isCreationDate?: boolean;
+      isDeletionDate?: boolean;
+      // this only works with arrays
+      isInnerPrimary?: boolean;
+      isUpdateDate?: boolean;
+      primary?: boolean;
+      primaryOrder?: number;
+      type?: EntitySchemaColumnType;
+      // https://www.npmjs.com/package/class-validator/v/0.6.0#defining-validation-schema-without-decorators
+      validationProperties?: ValidationSchema['properties'][''];
+    };
+  };
+  isArray?: boolean;
+  name: string;
+  nestedObjectContainerPath?: string;
+  paranoid?: boolean;
+  storeKey: string;
+}
+
+export enum EntitySchemaColumnType {
+  // eslint-disable-next-line no-unused-vars
+  Array = 'array',
+  // eslint-disable-next-line no-unused-vars
+  Boolean = 'boolean',
+  // eslint-disable-next-line no-unused-vars
+  Integer = 'integer',
+  // eslint-disable-next-line no-unused-vars
+  Object = 'object',
+  // eslint-disable-next-line no-unused-vars
+  String = 'string',
+  // eslint-disable-next-line no-unused-vars
+  TimestampTz = 'timestampTz',
+  // eslint-disable-next-line no-unused-vars
+  UUIDV4 = 'uuidv4'
+}
+
+export interface FilterItemOptions {
+  keysToSkip?: GenericObject<boolean>;
+  skippableKeysToForceCheck?: GenericObject<boolean>;
+}
+
+export interface GetValuesFromResultsOptions {
+  filters?: GenericObject<unknown>;
+  flattenArray?: boolean;
+  hasNonPrimaryKeyFilters?: boolean;
+  primaryKeyFiltersToForceCheck?: GenericObject<boolean>;
+}
+
+export interface PrepareOptions {
+  generatePrimaryKeys: boolean;
+  onConflict?: SaveOptionsOnConflict;
+  validate?: boolean;
+}
+
+export interface RedisRepositoryModuleOptions {
+  dataModuleName: string;
+  schema: EntitySchema;
+}
+
+export interface RepositoryFindOptions {
+  filters?: GenericObject<unknown>;
+  findAll?: boolean;
+  individualSearch?: boolean;
+  page?: number;
+  perPage?: number;
+  withValues?: boolean;
+}
+
+export interface RepositoryFindPrivateOptions {
+  requirePrimaryKeys?: boolean;
+}
+
+export interface SaveOptions {
+  delete?: boolean;
+  generatePrimaryKeys: boolean;
+  onConflict?: SaveOptionsOnConflict;
+  transactionId?: string;
+  ttl?: number;
+  validate?: boolean;
+}
+
+export enum SaveOptionsOnConflict {
+  // eslint-disable-next-line no-unused-vars
+  DoNothing = 'doNothing',
+  // eslint-disable-next-line no-unused-vars
+  ThrowError = 'throwError',
+  // eslint-disable-next-line no-unused-vars
+  Update = 'update'
+}

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

@@ -0,0 +1,60 @@
+import { describe, expect, it } from 'vitest';
+
+import { EntitySchema, RedisRepositoryModule, RedisRepositoryService } from './index';
+
+import { Constants } from '../common/definitions';
+import { RedisStoreService } from '../store';
+
+interface ProviderObject {
+  provide: unknown;
+  useValue?: unknown;
+  useFactory?: (_arg: unknown) => unknown;
+  inject?: string[];
+}
+
+describe('RedisRepositoryModule', () => {
+  const moduleName = 'test';
+  const storeKey = 'test-store';
+
+  describe('register', () => {
+    const dummySchema: EntitySchema = { columns: {}, name: 'testSchema' };
+    const options = { dataModuleName: moduleName, schema: dummySchema, storeKey };
+    const dynamicModule = RedisRepositoryModule.register(options);
+    const expectedStoreServiceToken = `${moduleName}${Constants.REDIS_CLIENT_STORE_SERVICE_SUFFIX}`;
+    it('should return a dynamic module with the expected properties', () => {
+      expect(dynamicModule.module).toBe(RedisRepositoryModule);
+      expect(dynamicModule.imports).toEqual([]);
+      expect(dynamicModule.providers).toHaveLength(4);
+      expect(dynamicModule.exports).toEqual([RedisRepositoryService, RedisStoreService]);
+    });
+    it('should include a provider for Constants.REDIS_REPOSITORY_SCHEMA with useValue equal to schema', () => {
+      const provider = dynamicModule.providers!.find(
+        (p: unknown): p is ProviderObject =>
+          typeof p === 'object' &&
+          p !== null &&
+          'provide' in p &&
+          (p as ProviderObject).provide === Constants.REDIS_REPOSITORY_SCHEMA
+      ) as ProviderObject | undefined;
+      expect(provider).toBeDefined();
+      expect(provider!.useValue).toEqual(dummySchema);
+    });
+    it('should include a provider for RedisStoreService with correct useFactory and inject', () => {
+      const provider = dynamicModule.providers!.find(
+        (p: unknown): p is ProviderObject =>
+          typeof p === 'object' && p !== null && 'provide' in p && (p as ProviderObject).provide === RedisStoreService
+      ) as ProviderObject | undefined;
+      expect(provider).toBeDefined();
+      expect(typeof provider!.useFactory).toBe('function');
+      expect(provider!.inject).toEqual([expectedStoreServiceToken]);
+      // Verify the useFactory function returns its input
+      const dummyInstance: RedisStoreService = {} as RedisStoreService;
+      const factoryResult = provider!.useFactory!(dummyInstance);
+      expect(factoryResult).toBe(dummyInstance);
+    });
+    it('should include RedisRepositoryService as a provider', () => {
+      // RedisRepositoryService is provided as a class (not an object provider)
+      const providerExists = dynamicModule.providers!.some((p: unknown) => p === RedisRepositoryService);
+      expect(providerExists).toBe(true);
+    });
+  });
+});

package/src/repository/redis.repository.module.ts

@@ -0,0 +1,34 @@
+import { DynamicModule, Module } from '@nestjs/common';
+
+import { Constants as CoreConstants } from '@node-c/core';
+
+import { RedisRepositoryModuleOptions } from './redis.repository.definitions';
+import { RedisRepositoryService } from './redis.repository.service';
+
+import { Constants } from '../common/definitions';
+import { RedisStoreService } from '../store';
+
+@Module({})
+export class RedisRepositoryModule {
+  static register<Entity>(options: RedisRepositoryModuleOptions): DynamicModule {
+    const { dataModuleName, schema } = options;
+    return {
+      module: RedisRepositoryModule,
+      imports: [],
+      providers: [
+        {
+          provide: Constants.REDIS_REPOSITORY_SCHEMA,
+          useValue: schema
+        },
+        { provide: CoreConstants.DATA_MODULE_NAME, useValue: dataModuleName },
+        {
+          provide: RedisStoreService,
+          useFactory: (redisStoreService: RedisStoreService) => redisStoreService,
+          inject: [`${dataModuleName}${Constants.REDIS_CLIENT_STORE_SERVICE_SUFFIX}`]
+        },
+        RedisRepositoryService<Entity>
+      ],
+      exports: [RedisRepositoryService<Entity>, RedisStoreService]
+    };
+  }
+}