zync-nest-data-module 1.0.0 → 1.1.38

package/libs/src/redis/redis.module.ts

@@ -0,0 +1,30 @@
+// src/redis/redis.module.ts
+import { Global, Module } from "@nestjs/common";
+import Redis from "ioredis";
+import { ConfigModule } from "@nestjs/config";
+import { RedisService } from "./redis.service";
+
+@Global()
+@Module({
+  imports: [ConfigModule],
+  providers: [
+    {
+      provide: "REDIS_CLIENT",
+      useFactory: async () => {
+        const client = new Redis({
+          host: process.env.redis_host || "127.0.0.1",
+          port: Number(process.env.redis_port) || 6379,
+          password: process.env.redis_password || undefined,
+          db: Number(process.env.redis_database) || 0
+        });
+
+        client.on("connect", () => console.log("✅ Redis connected"));
+        client.on("error", (err) => console.error("❌ Redis error:", err));
+
+        return client;
+      }
+    },
+  ],
+  exports: ["REDIS_CLIENT", RedisService]
+})
+export class RedisModule { }

package/libs/src/redis/redis.service.ts

@@ -0,0 +1,137 @@
+import { Injectable, Logger } from "@nestjs/common";
+import { RedisPubSub } from "graphql-redis-subscriptions";
+import { EntityData, Client as RedisOmClient, Repository, Schema, SchemaDefinition, Search } from "redis-om";
+import { IPageParams } from "../database/database.scheme";
+
+@Injectable()
+export abstract class RedisService<T extends EntityData> extends RedisPubSub {
+  private readonly logger = new Logger(RedisService.name);
+  public readonly baseKey = `${process.env.redis_prefix || "zync_redis_data"}:`;
+  private redisOmClient: RedisOmClient | null = null;
+
+  constructor() {
+    super({
+      connection: {
+        host: process.env.redis_host || "localhost",
+        port: Number(process.env.redis_port) || 6379,
+        username: process.env.redis_username || undefined,
+        password: process.env.redis_password || undefined,
+        db: Number(process.env.redis_database) || 0
+      }
+    });
+  }
+
+  public abstract cacheKey: string;
+
+  protected abstract buildQuery(search: Search, query: any): Search;
+
+  protected abstract mapSchema(): Record<string, any>;
+
+  protected async repository(): Promise<Repository<T>> {
+    const schema = this.createSchema(this.cacheKey, this.mapSchema());
+    const repository = await this.getRepository(schema);
+    try {
+      await repository.createIndex();
+    } catch (error) {
+      this.logger.error(`Error creating index for ${this.cacheKey}: ${error}`);
+    }
+    return repository;
+  }
+
+  private createSchema<M extends EntityData>(name: string, fields: Record<string, any>): Schema<M> {
+    return new Schema<M>(`${this.baseKey}${name}`, fields as SchemaDefinition<M>, {
+      dataStructure: "JSON",
+      indexName: `${this.baseKey}${name}:idx`
+    });
+  }
+
+  private async getRedisOmClient(): Promise<RedisOmClient> {
+    if (this.redisOmClient) return this.redisOmClient;
+
+    const host = process.env.redis_host || "127.0.0.1";
+    const port = Number(process.env.redis_port) || 6379;
+    const password = process.env.redis_password;
+    const db = Number(process.env.redis_database) || 0;
+
+    const authSegment = password ? `:${password}@` : "";
+    const url = `redis://${authSegment}${host}:${port}/${db}`;
+
+    const client = new RedisOmClient();
+    await client.open(url);
+    this.redisOmClient = client;
+    return client;
+  }
+
+  public async getRepository(schema: Schema<any>): Promise<Repository<any>> {
+    return (await this.getRedisOmClient()).fetchRepository(schema);
+  }
+
+
+  public async create(data: Partial<T> | T): Promise<T> {
+    const repository = await this.repository();
+    const _id = (data as any)._id as string;
+    const existing = _id ? await this.findById(_id) : null;
+    if (existing) {
+      return await this.update(_id, data);
+    }
+    return await repository.save(JSON.parse(JSON.stringify(data)));
+  }
+
+  public async update(_id: string, data: Partial<T> | T): Promise<T> {
+    const repository = await this.repository();
+    const entityId = await this.getEntityId(_id);
+
+    // Fetch the entity with its internal metadata (including entityId)
+    const entity = await repository.fetch(entityId);
+
+    // Update the entity properties
+    Object.assign(entity, JSON.parse(JSON.stringify(data)));
+
+    return await repository.save(entity);
+  }
+
+  public async delete(id: string): Promise<boolean> {
+    const repository = await this.repository();
+    await repository.remove(await this.getEntityId(id));
+    return true;
+  }
+
+  public async findById(_id: string): Promise<T> {
+    const repository = await this.repository();
+    return await repository
+      .search()
+      .where("_id" as any)
+      .eq(_id)
+      .return.first();
+  }
+
+
+  public async getEntityId(_id: string): Promise<string> {
+    const repository = await this.repository();
+    return await repository
+      .search()
+      .where("_id" as any)
+      .eq(_id)
+      .return.firstId();
+  }
+
+  public async findOne(query: Partial<T>): Promise<T> {
+    const repository = await this.repository();
+    const search = this.buildQuery(repository.search(), query);
+    return (await search.return.first()) as T;
+  }
+
+  public async find(query: Partial<T>): Promise<T[]> {
+    const repository = await this.repository();
+    const search = this.buildQuery(repository.search(), query);
+    return (await search.return.all()) as T[];
+  }
+
+  public async page(query: Partial<T> & IPageParams): Promise<{ totalRecords: number; data: Array<Partial<T>> }> {
+    const repository = await this.repository();
+    const search = this.buildQuery(repository.search(), query);
+    const totalRecords = await search.return.count();
+    const data = (await search.return.page(query.skip, query.take)) as T[];
+    return { totalRecords, data };
+  }
+}

package/libs/src/service/service.ts

@@ -1,11 +1,11 @@
-import { forwardRef, Inject } from "@nestjs/common";
+import { forwardRef, Inject, Logger } from "@nestjs/common";
 import { AbstractBaseRepository, IPageParams, TransactionManager, TransactionSession } from "../database";
 
 class BaseService<T> {
   constructor(
     @Inject(forwardRef(() => AbstractBaseRepository))
     protected readonly repository: AbstractBaseRepository<any>
-  ) {}
+  ) { }
 
   public async create(data: Partial<T> | T): Promise<T> {
     return await this.repository.create(data);
@@ -57,7 +57,7 @@ class BaseService<T> {
 }
 
 export abstract class AbstractBaseService<T> extends BaseService<T> {
-  private _session: TransactionSession;
+  protected readonly logger: Logger = new Logger(AbstractBaseService.name);
   constructor(
     @Inject(forwardRef(() => AbstractBaseRepository))
     protected readonly repository: AbstractBaseRepository<any>,
@@ -69,60 +69,53 @@ export abstract class AbstractBaseService<T> extends BaseService<T> {
 
   protected abstract setSession(session: any): void;
 
-  public get session(): TransactionSession {
-    return this._session;
-  }
 
-  public set session(v: TransactionSession) {
-    this._session = v;
-    this.repository.session = this._session;
+  public get session(): TransactionSession {
+    return TransactionManager.getCurrentSession();
   }
 
   public get sessionName(): string {
     return this.transactionManager.sessionName;
   }
 
-  public async withRetryTransaction(
-    sessionName: string,
-    operations: () => Promise<T>,
-    retries: number = 3
-  ): Promise<T> {
-    if (!process.env.mongodb_transaction_enabled) {
-      return await operations();
-    }
-
-    try {
-      await this.startSession(sessionName);
-
-      let attempt = 0;
-      while (attempt < retries) {
-        try {
-          const op = await operations();
-          await this.commitSession(sessionName);
-          return op;
-        } catch (error) {
-          if (this.isRetryableError(error)) {
-            console.log(`[TransactionManager] Retrying transaction...`);
-            await this.delay(1000 * (attempt + 1)); // Exponential backoff
-            await this.transactionManager.abortTransaction();
-            await this.startSession(sessionName, true);
-          } else {
-            await this.abortSession();
-            throw error;
+  public async withRetryTransaction(sessionName: string, operations: () => Promise<T>, retries: number = 3): Promise<T> {
+    if (process.env.mongodb_transaction_enable !== "true") return await operations();
+
+    return this.transactionManager.run(async () => {
+      try {
+        await this.startSession(sessionName);
+
+        let attempt = 0;
+        while (attempt < retries) {
+          try {
+            const op = await operations();
+            await this.commitSession(sessionName);
+            return op;
+          } catch (error) {
+            if (this.isRetryableError(error)) {
+              this.logger.log(`[TransactionManager] Retrying transaction...`);
+              await this.delay(1000 * (attempt + 1)); // Exponential backoff
+              await this.transactionManager.abortTransaction();
+              await this.startSession(sessionName, true);
+            } else {
+              await this.abortSession();
+              throw error;
+            }
           }
+          attempt++;
+        }
+      } catch (error) {
+        this.logger.error(`[TransactionManager] Error in transaction`, error);
+        await this.abortSession();
+        throw error;
+      } finally {
+        this.logger.log(`[TransactionManager] Finally block`);
+        if (this.transactionManager.sessionName == sessionName) {
+          await this.endSession();
         }
-        attempt++;
-      }
-    } catch (error) {
-      console.log(`[TransactionManager] Error in transaction`, error);
-      await this.abortSession();
-      throw error;
-    } finally {
-      console.log(`[TransactionManager] Finally block`);
-      if (this.transactionManager.sessionName == sessionName) {
-        await this.endSession();
       }
-    }
+    });
+
   }
 
   private isRetryableError(error: any): boolean {
@@ -137,51 +130,38 @@ export abstract class AbstractBaseService<T> extends BaseService<T> {
 
   protected async startSession(sessionName: string, force: boolean = false) {
     if (this.transactionManager.sessionName && !force) {
-      this.session = this._session;
-      this.repository.session = this._session;
-      console.log(
-        `[TransactionManager] startSession ${this.transactionManager.sessionName} - ${sessionName} is already active`
-      );
+      this.logger.log(`[TransactionManager] startSession ${this.transactionManager.sessionName} - ${sessionName} is already active`);
       return;
     }
 
-    console.log(`[TransactionManager] startSession  ${sessionName} is started`);
+    this.logger.log(`[TransactionManager] startSession  ${sessionName} is started`);
 
-    this._session = await this.transactionManager.startTransaction();
-    this.repository.session = this._session;
+    await this.transactionManager.startTransaction();
     this.transactionManager.sessionName = sessionName;
-    this.setSession(this._session);
+
   }
 
   protected async commitSession(sessionName: string) {
     if (this.transactionManager.sessionName !== sessionName) {
-      console.log(
-        `[TransactionManager] Session ${this.transactionManager.sessionName} - ${sessionName} is not active`
-      );
+      this.logger.log(`[TransactionManager] Session ${this.transactionManager.sessionName} - ${sessionName} is not active`);
       return;
     }
 
     await this.transactionManager.commitTransaction();
-    this._session = null;
-    this.repository.session = null;
     this.transactionManager.sessionName = undefined;
-    this.setSession(null);
+
   }
 
   public async abortSession() {
     await this.transactionManager.abortTransaction();
-    this._session = null;
-    this.repository.session = null;
     this.transactionManager.sessionName = undefined;
-    this.setSession(null);
+
   }
 
   public async endSession() {
     await this.transactionManager.endTransaction();
-    this._session = null;
-    this.repository.session = null;
     this.transactionManager.sessionName = undefined;
-    this.setSession(null);
+
   }
 
   protected getObjectId(): string | any {

package/libs/src/test/test.controller.ts

@@ -0,0 +1,59 @@
+import { Body, Controller, Delete, Get, Param, Post, Put, Query } from "@nestjs/common";
+import { ApiOperation, ApiParam, ApiQuery, ApiResponse, ApiTags } from "@nestjs/swagger";
+import { CreateTestInput, Test, TestPageInput, TestPageResult, TestQueryInput, UpdateTestInput } from "./test.dto";
+import { TestRedisService } from "./test.redis";
+
+@ApiTags("Test")
+@Controller("test")
+export class TestController {
+  constructor(private readonly testRedisSvc: TestRedisService) {}
+
+  @Post()
+  @ApiOperation({ summary: "Create Test" })
+  @ApiResponse({ status: 201, description: "Test created successfully", type: Test })
+  public async create(@Body() test: CreateTestInput): Promise<Test> {
+    return this.testRedisSvc.create(test as any);
+  }
+
+  @Put(":id")
+  @ApiOperation({ summary: "Update Test" })
+  @ApiParam({ name: "id", description: "Test ID" })
+  @ApiResponse({ status: 200, description: "Test updated", type: Test })
+  public async update(@Param("id") id: string, @Body() test: UpdateTestInput): Promise<Test> {
+    return this.testRedisSvc.update(id, { ...test } as any);
+  }
+
+  @Delete(":id")
+  @ApiOperation({ summary: "Delete Test" })
+  @ApiParam({ name: "id", description: "Test ID" })
+  @ApiResponse({ status: 200, description: "Test deleted" })
+  public async delete(@Param("id") id: string): Promise<{ success: boolean }> {
+    await this.testRedisSvc.delete(id);
+    return { success: true };
+  }
+
+  @Get("findOne")
+  @ApiOperation({ summary: "Find one Test" })
+  @ApiQuery({ name: "_id", required: false, description: "Test ID" })
+  @ApiResponse({ status: 200, description: "Returns the found test", type: Test })
+  public async findOne(@Query() query: TestQueryInput): Promise<Test> {
+    return this.testRedisSvc.findOne(query as any);
+  }
+
+  @Get("find")
+  @ApiOperation({ summary: "Find Tests" })
+  @ApiQuery({ name: "query", required: false, description: "Test query" })
+  @ApiResponse({ status: 200, description: "Returns the found tests", type: [Test] })
+  public async find(@Query() query: TestQueryInput): Promise<Test[]> {
+    return this.testRedisSvc.find(query as any);
+  }
+
+  @Get("page")
+  @ApiOperation({ summary: "Get paginated list of Tests" })
+  @ApiQuery({ name: "page", type: "number", required: false })
+  @ApiQuery({ name: "limit", type: "number", required: false })
+  @ApiResponse({ status: 200, description: "Returns a page of tests", type: TestPageResult })
+  public async page(@Query() pageQuery: TestPageInput): Promise<{ totalRecords: number; data: Array<Partial<Test>> }> {
+    return this.testRedisSvc.page({ ...pageQuery } as any);
+  }
+}

package/libs/src/test/test.module.ts

@@ -1,20 +1,24 @@
 import { forwardRef, Module } from "@nestjs/common";
 import { MongooseModule } from "@nestjs/mongoose";
+import { DatabaseModule } from "../database";
 import { TestRepository } from "./test.repository";
 import { TestResolver } from "./test.resolver";
 import { Test, TestSchema } from "./test.schema";
 import { TestService } from "./test.service";
+import { TestController } from "./test.controller";
+import { TestRedisService } from "./test.redis";
 
 const TestMongooseModule = MongooseModule.forFeature([
   {
     name: Test.name,
-    schema: TestSchema,
-  },
+    schema: TestSchema
+  }
 ]);
 
 @Module({
-  imports: [TestMongooseModule],
-  providers: [TestRepository, TestService, TestResolver],
+  imports: [TestMongooseModule, DatabaseModule.forFeature([{ name: Test.name, schema: TestSchema }])],
+  providers: [TestRepository, TestService, TestResolver, TestRedisService],
   exports: [TestService],
+  controllers: [TestController]
 })
 export class TestModule {}

package/libs/src/test/test.redis.ts

@@ -0,0 +1,19 @@
+import { EntityData } from "redis-om";
+import { RedisService } from "../redis/redis.service";
+import { Test } from "./test.schema";
+
+export class TestRedisService extends RedisService<Test & EntityData & { _id: string }> {
+  public cacheKey = "test";
+
+  public mapSchema(): Record<string, any> {
+    return {
+      name: { type: "string", index: true },
+      createdAt: { type: "number" },
+      updatedAt: { type: "number" }
+    };
+  }
+
+  public buildQuery(query: any): any {
+    return query;
+  }
+}

package/libs/src/test/test.resolver.ts

@@ -1,44 +1,35 @@
 import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
-import {
-  CreateTestInput,
-  Test,
-  TestPageInput,
-  TestPageResult,
-  TestQueryInput,
-  UpdateTestInput,
-} from "./test.dto";
+import { CreateTestInput, Test, TestPageInput, TestPageResult, TestQueryInput, UpdateTestInput } from "./test.dto";
 import { TestService } from "./test.service";
+import { TestRedisService } from "./test.redis";
 
 @Resolver(() => Test)
 export class TestResolver {
-  constructor(private readonly testSvc: TestService) {}
+  constructor(private readonly testSvc: TestService, private readonly testRedisSvc: TestRedisService) {}
 
   @Mutation((returns) => Test, { name: "createTest" })
-  public async create(@Args("test") testSvc: CreateTestInput) {
-    return this.testSvc.create(testSvc as any);
+  public async create(@Args("test") test: CreateTestInput) {
+    return this.testRedisSvc.create(test as any);
   }
 
   @Mutation((returns) => Test, { name: "updateTest" })
-  public async update(
-    @Args("_id") id: string,
-    @Args("test") test: UpdateTestInput
-  ) {
-    return this.testSvc.update(id, { ...test } as any);
+  public async update(@Args("_id") id: string, @Args("test") test: UpdateTestInput) {
+    return this.testRedisSvc.update(id, { ...test } as any);
   }
 
   @Mutation((returns) => Boolean, { name: "deleteTest" })
   public async delete(@Args("_id") id: string) {
-    await this.testSvc.delete(id);
+    await this.testRedisSvc.delete(id);
     return true;
   }
 
   @Query((returns) => Test, { name: "findOneTest" })
   public async findOne(@Args("test") test: TestQueryInput) {
-    return this.testSvc.findOne(test as any);
+    return this.testRedisSvc.findOne(test as any);
   }
 
   @Query((returns) => TestPageResult, { name: "testPage" })
   public async page(@Args("page") page: TestPageInput) {
-    return this.testSvc.page({ ...page } as any);
+    return this.testRedisSvc.page({ ...page } as any);
   }
 }

package/package.json

@@ -1,41 +1,38 @@
 {
   "name": "zync-nest-data-module",
-  "version": "1.0.0",
+  "version": "1.1.38",
   "description": "NestJS database module with database backup and file upload utilities",
+  "keywords": [
+    "nestjs",
+    "database",
+    "backup",
+    "upload",
+    "utilities"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/zynctech/zync-nest-data-module.git"
+  },
+  "license": "ISC",
+  "author": "sabiridwan",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc -p libs/tsconfig.lib.json",
     "build:lib": "rimraf dist && tsc -p libs/tsconfig.lib.json",
     "build:watch": "tsc -p libs/tsconfig.lib.json --watch",
     "clean": "rimraf dist",
     "prepublishOnly": "npm run build",
+    "publish:update": "npm publish --registry https://registry.asynctechs.com/",
     "start": "npm run build && node dist/main.js",
     "start:dev": "npm run build:watch & nodemon dist/main.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
     "update-links": "node update-links.js",
-    "update-links:minor": "node update-links.js minor",
     "update-links:major": "node update-links.js major",
+    "update-links:minor": "node update-links.js minor",
     "update-links:no-build": "node update-links.js --skip-build",
     "update-links:no-version": "node update-links.js --skip-version --skip-build"
   },
-  "keywords": [
-    "nestjs",
-    "database",
-    "backup",
-    "upload",
-    "utilities"
-  ],
-  "author": "sabiridwan",
-  "license": "ISC",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/zynctech/zync-nest-data-module.git"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "packageManager": "pnpm@10.14.0",
   "dependencies": {
     "@apollo/server": "^5.0.0",
     "@as-integrations/express5": "^1.1.2",
@@ -47,7 +44,6 @@
     "@nestjs/config": "^4.0.2",
     "@nestjs/event-emitter": "^3.0.1",
     "@nestjs/graphql": "^13.1.0",
-    "@nestjs/mongoose": "^11.0.3",
     "@nestjs/swagger": "^11.2.0",
     "aws-sdk": "^2.1692.0",
     "axios": "^1.11.0",
@@ -60,30 +56,53 @@
     "firebase-admin": "^13.5.0",
     "googleapis": "^159.0.0",
     "graphql": "^16.11.0",
+    "graphql-redis-subscriptions": "^2.7.0",
     "graphql-upload-ts": "^2.1.3",
+    "ioredis": "^5.8.2",
     "moment": "^2.30.1",
     "mongodb": "^6.20.0",
-    "mongoose": "^8.19.2",
     "mongoose-delete": "^1.0.2",
     "puppeteer": "^24.19.0",
     "qs": "^6.14.0",
     "razorpay": "^2.9.6",
     "rxjs": "^7.8.2",
-    "sharp": "^0.34.3",
     "shortid": "^2.2.17",
     "slugify": "^1.6.6",
     "uuid": "^11.1.0",
     "xlsx": "^0.18.5",
-    "zync-nest-library": "^1.0.23"
+    "zync-nest-library": "^1.0.30"
   },
   "devDependencies": {
     "@nestjs/cli": "^11.0.10",
     "@nestjs/core": "^11.1.6",
+    "@nestjs/mongoose": "^11.0.3",
     "@nestjs/platform-express": "^11.1.6",
+    "@nestjs/schedule": "^6.0.1",
+    "@types/nanoid": "^3.0.0",
     "@types/node": "^24.3.1",
+    "mongoose": "^8.19.2",
+    "nanoid": "^5.1.6",
+    "nest-winston": "^1.10.2",
     "nodemon": "^3.0.2",
+    "randomatic": "^3.1.1",
+    "redis-om": "^0.4.7",
     "rimraf": "^6.0.1",
     "ts-morph": "^24.0.0",
     "typescript": "^5.7.2"
-  }
-}
+  },
+  "peerDependencies": {
+    "@nestjs/mongoose": "^11.0.3",
+    "@nestjs/schedule": "^6.0.1",
+    "@types/nanoid": "^3.0.0",
+    "mongoose": "^8.19.2",
+    "nanoid": "^5.1.6",
+    "nest-winston": "^1.10.2",
+    "randomatic": "^3.1.1",
+    "redis-om": "^0.4.7"
+  },
+  "packageManager": "pnpm@10.14.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "registry": "https://registry.asynctechs.com"
+}