zync-nest-data-module 1.1.38 → 1.1.41

package/libs/src/service/service.ts

@@ -1,181 +0,0 @@
-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);
-  }
-
-  public async update(_id: string, data: Partial<T> | T): Promise<T> {
-    return await this.repository.update(_id, data);
-  }
-
-  public async updateMany(query: Partial<T>, model: Partial<T>): Promise<void> {
-    return await this.repository.updateMany(query, model);
-  }
-
-  public async findById(_id: string): Promise<T> {
-    return await this.repository.findById(_id);
-  }
-
-  public async findOne(query: Partial<T>): Promise<T> {
-    return await this.repository.findOne(query);
-  }
-
-  public async find(query: Partial<T>): Promise<T[]> {
-    return await this.repository.find(query);
-  }
-
-  public async findLast(query?: Partial<T>): Promise<T> {
-    return await this.repository.findLast(query);
-  }
-
-  public async delete(_id: string): Promise<Boolean> {
-    await this.repository.delete(_id);
-    return true;
-  }
-
-  public async deleteMany(query: Partial<T>): Promise<Boolean> {
-    await this.repository.deleteMany(query);
-    return true;
-  }
-
-  public async page(
-    query: Partial<T> & IPageParams
-  ): Promise<{ totalRecords: number; data: Array<T> }> {
-    return await this.repository.page(query);
-  }
-
-  public async count(query: Partial<T>): Promise<number> {
-    return this.repository.count(query);
-  }
-}
-
-export abstract class AbstractBaseService<T> extends BaseService<T> {
-  protected readonly logger: Logger = new Logger(AbstractBaseService.name);
-  constructor(
-    @Inject(forwardRef(() => AbstractBaseRepository))
-    protected readonly repository: AbstractBaseRepository<any>,
-    @Inject(forwardRef(() => TransactionManager))
-    public readonly transactionManager: TransactionManager
-  ) {
-    super(repository);
-  }
-
-  protected abstract setSession(session: any): void;
-
-
-  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_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();
-        }
-      }
-    });
-
-  }
-
-  private isRetryableError(error: any): boolean {
-    return (
-      error.code === 112 // WriteConflict
-    );
-  }
-
-  private delay(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  protected async startSession(sessionName: string, force: boolean = false) {
-    if (this.transactionManager.sessionName && !force) {
-      this.logger.log(`[TransactionManager] startSession ${this.transactionManager.sessionName} - ${sessionName} is already active`);
-      return;
-    }
-
-    this.logger.log(`[TransactionManager] startSession  ${sessionName} is started`);
-
-    await this.transactionManager.startTransaction();
-    this.transactionManager.sessionName = sessionName;
-
-  }
-
-  protected async commitSession(sessionName: string) {
-    if (this.transactionManager.sessionName !== sessionName) {
-      this.logger.log(`[TransactionManager] Session ${this.transactionManager.sessionName} - ${sessionName} is not active`);
-      return;
-    }
-
-    await this.transactionManager.commitTransaction();
-    this.transactionManager.sessionName = undefined;
-
-  }
-
-  public async abortSession() {
-    await this.transactionManager.abortTransaction();
-    this.transactionManager.sessionName = undefined;
-
-  }
-
-  public async endSession() {
-    await this.transactionManager.endTransaction();
-    this.transactionManager.sessionName = undefined;
-
-  }
-
-  protected getObjectId(): string | any {
-    return this.repository.getObjectId();
-  }
-
-  protected toObjectId(value: string | any): any {
-    return this.repository.toObjectId(value);
-  }
-
-  public async checkExist(id: any): Promise<void> {
-    const exist = await this.repository.findOne(id);
-    if (!exist) {
-      throw new Error("Record does not exist");
-    }
-  }
-}

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

@@ -1,59 +0,0 @@
-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.dto.ts

@@ -1,41 +0,0 @@
-import { Field, InputType, ObjectType, PartialType } from "@nestjs/graphql";
-
-@ObjectType()
-export class Test {
-  @Field({ nullable: true })
-  name: string;
-}
-
-@InputType()
-export class TestCommonInput {
-  @Field({ nullable: true })
-  name: string;
-}
-
-@InputType()
-export class CreateTestInput extends TestCommonInput {}
-
-@InputType()
-export class UpdateTestInput extends PartialType(TestCommonInput) {}
-
-@InputType()
-export class TestQueryInput {
-  @Field({ nullable: true })
-  keyword: string;
-}
-
-@ObjectType()
-export class TestPageResult {
-  @Field({})
-  totalRecords: number;
-  @Field((type) => [Test])
-  data: Array<Test>;
-}
-
-@InputType()
-export class TestPageInput extends TestQueryInput {
-  @Field({})
-  skip: number;
-  @Field({})
-  take: number;
-}

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

@@ -1,24 +0,0 @@
-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
-  }
-]);
-
-@Module({
-  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

@@ -1,19 +0,0 @@
-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.repository.ts

@@ -1,44 +0,0 @@
-import { Injectable } from "@nestjs/common";
-import { InjectModel } from "@nestjs/mongoose";
-import moment from "moment";
-import { SoftDeleteModel } from "mongoose-delete";
-import { AbstractBaseRepository } from "../database/database.repository";
-import { Test, TestDocument, TestSchema } from "./test.schema";
-
-@Injectable()
-export class TestRepository extends AbstractBaseRepository<TestDocument> {
-  constructor(
-    @InjectModel(Test.name)
-    public dbModel: SoftDeleteModel<TestDocument>
-  ) {
-    super(dbModel);
-  }
-
-  public async mapData(data: any, isCreate: boolean): Promise<TestDocument> {
-    const payload: any = data;
-
-    if (isCreate) {
-      payload.ref = payload.ref || (await this.generateRef());
-      payload.createdBy = payload.createdBy;
-      payload.createdAt = payload.createdAt
-        ? moment(payload.createdAt).valueOf()
-        : moment().valueOf();
-    } else {
-      payload.updatedBy = payload.updatedBy;
-      payload.updatedAt = payload.updatedAt
-        ? moment(payload.updatedAt).valueOf()
-        : moment().valueOf();
-    }
-    return this.mapIds(payload);
-  }
-
-  protected buildQuery(query: Partial<TestDocument>) {
-    const andConditions: any[] = [];
-
-    this.schemaKeysQuery(TestSchema, { query }, (condition: any) => {
-      andConditions.push(condition);
-    });
-
-    return this.cleanupQuery(andConditions);
-  }
-}

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

@@ -1,35 +0,0 @@
-import { Args, Mutation, Query, Resolver } from "@nestjs/graphql";
-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, private readonly testRedisSvc: TestRedisService) {}
-
-  @Mutation((returns) => Test, { name: "createTest" })
-  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.testRedisSvc.update(id, { ...test } as any);
-  }
-
-  @Mutation((returns) => Boolean, { name: "deleteTest" })
-  public async delete(@Args("_id") id: string) {
-    await this.testRedisSvc.delete(id);
-    return true;
-  }
-
-  @Query((returns) => Test, { name: "findOneTest" })
-  public async findOne(@Args("test") test: TestQueryInput) {
-    return this.testRedisSvc.findOne(test as any);
-  }
-
-  @Query((returns) => TestPageResult, { name: "testPage" })
-  public async page(@Args("page") page: TestPageInput) {
-    return this.testRedisSvc.page({ ...page } as any);
-  }
-}

package/libs/src/test/test.schema.ts

@@ -1,21 +0,0 @@
-import { Prop, Schema, SchemaFactory } from "@nestjs/mongoose";
-import { Document } from "mongoose";
-import { BaseSchema, IPageParams } from "../database/database.scheme";
-export type TestDocument = Test & Document;
-
-@Schema({ collection: "tests" })
-export class Test extends BaseSchema {
-  @Prop({ required: true })
-  name: string;
-}
-
-export const TestSchema = SchemaFactory.createForClass(Test);
-
-export class TestQuery extends Test {
-  keyword?: string;
-}
-
-export class PageParams extends TestQuery implements IPageParams {
-  skip: number;
-  take: number;
-}

package/libs/src/test/test.service.ts

@@ -1,19 +0,0 @@
-import { forwardRef, Inject, Injectable } from "@nestjs/common";
-import { TestRepository } from "./test.repository";
-import { Test } from "./test.schema";
-import { TransactionManager } from "../database";
-import { AbstractBaseService } from "../service/service";
-
-@Injectable()
-export class TestService extends AbstractBaseService<Test> {
-  constructor(
-    @Inject(forwardRef(() => TestRepository))
-    private readonly testRepo: TestRepository,
-    @Inject(forwardRef(() => TransactionManager))
-    transactionManager: TransactionManager
-  ) {
-    super(testRepo, transactionManager);
-  }
-
-  protected setSession(session: any): void {}
-}

package/libs/tsconfig.lib.json

@@ -1,19 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "declaration": true,
-    "outDir": "../dist"
-  },
-  "include": [
-    "src/database/**/*",
-    "src/backup/**/*",
-    "src/service/**/*",
-    "src/index.ts",
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "test",
-    "**/*spec.ts",
-  ]
-}

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-    "compilerOptions": {
-        "module": "commonjs",
-        "declaration": true,
-        "removeComments": true,
-        "emitDecoratorMetadata": true,
-        "experimentalDecorators": true,
-        "allowSyntheticDefaultImports": true,
-        "target": "ES2021",
-        "sourceMap": true,
-        "outDir": "./dist",
-        "baseUrl": "./",
-        "incremental": true,
-        "skipLibCheck": true,
-        "strictNullChecks": false,
-        "noImplicitAny": false,
-        "strictBindCallApply": false,
-        "forceConsistentCasingInFileNames": false,
-        "noFallthroughCasesInSwitch": false,
-        "esModuleInterop": true
-    },
-    "include": [
-        "libs/**/*"
-    ],
-    "exclude": [
-        "node_modules",
-        "dist"
-    ]
-}

package/update-links.js

@@ -1,159 +0,0 @@
-#!/usr/bin/env node
-
-const { execSync } = require("child_process");
-const fs = require("fs");
-const path = require("path");
-
-/**
- * Script to update pnpm links when changes are made to zync-nest-library
- * This script will:
- * 1. Build the library
- * 2. Update the version in package.json
- * 3. Re-link to consuming projects
- */
-
-// Configuration - projects that use this library
-const CONSUMING_PROJECTS = [
-  "/Users/sabiridwan/Projects/Async/zyncount/zyncount-be",
-  "/Users/sabiridwan/Projects/MalikStream/ms-gold/msgld-be",
-];
-
-const LIBRARY_PATH =
-  "/Users/sabiridwan/Projects/Async/zync-library/zync-nest-libary";
-
-function execCommand(command, cwd = process.cwd()) {
-  try {
-    console.log(`\n🔧 Executing: ${command}`);
-    console.log(`📁 In directory: ${cwd}`);
-
-    const output = execSync(command, {
-      cwd,
-      stdio: "inherit",
-      encoding: "utf8",
-    });
-
-    return output;
-  } catch (error) {
-    console.error(`❌ Error executing command: ${command}`);
-    console.error(error.message);
-    process.exit(1);
-  }
-}
-
-function updateLibraryVersion(versionType = "patch") {
-  console.log(`\n📦 Updating library version (${versionType})...`);
-  execCommand(`npm version ${versionType} --no-git-tag-version`, LIBRARY_PATH);
-
-  // Get the new version
-  const packageJson = JSON.parse(
-    fs.readFileSync(path.join(LIBRARY_PATH, "package.json"), "utf8")
-  );
-  console.log(`✅ Updated to version: ${packageJson.version}`);
-  return packageJson.version;
-}
-
-function buildLibrary() {
-  console.log("\n🏗️  Building library...");
-  execCommand("pnpm run build", LIBRARY_PATH);
-  console.log("✅ Library built successfully");
-}
-
-function linkLibraryGlobally() {
-  console.log("\n🔗 Linking library globally...");
-  execCommand("pnpm link --global", LIBRARY_PATH);
-  console.log("✅ Library linked globally");
-}
-
-function updateConsumingProjects() {
-  console.log("\n🔄 Updating consuming projects...");
-
-  for (const projectPath of CONSUMING_PROJECTS) {
-    if (!fs.existsSync(projectPath)) {
-      console.log(`⚠️  Project not found: ${projectPath}`);
-      continue;
-    }
-
-    console.log(`\n📂 Updating project: ${path.basename(projectPath)}`);
-
-    // Unlink first (in case it's already linked)
-    try {
-      execCommand("pnpm unlink zync-nest-library", projectPath);
-    } catch (error) {
-      // Ignore errors if not linked
-    }
-
-    // Link the new version
-    execCommand("pnpm link zync-nest-library", projectPath);
-    console.log(`✅ Updated ${path.basename(projectPath)}`);
-  }
-}
-
-function main() {
-  console.log("🚀 Starting pnpm link update process...");
-
-  const args = process.argv.slice(2);
-  const versionType = args[0] || "patch"; // patch, minor, major
-  const skipVersionUpdate = args.includes("--skip-version");
-  const skipBuild = args.includes("--skip-build");
-
-  try {
-    // Update version if not skipped
-    if (!skipVersionUpdate) {
-      updateLibraryVersion(versionType);
-    }
-
-    // Build library if not skipped
-    if (!skipBuild) {
-      buildLibrary();
-    }
-
-    // Link library globally
-    linkLibraryGlobally();
-
-    // Update consuming projects
-    updateConsumingProjects();
-
-    console.log("\n🎉 Pnpm link update completed successfully!");
-
-    // Show usage information
-    console.log("\n📋 Next steps:");
-    console.log("1. Test your changes in the consuming projects");
-    console.log("2. When ready, publish the library: npm publish");
-    console.log(
-      "3. Update consuming projects to use published version: pnpm update zync-nest-library"
-    );
-  } catch (error) {
-    console.error("\n❌ Update process failed:", error.message);
-    process.exit(1);
-  }
-}
-
-// Show help
-if (process.argv.includes("--help") || process.argv.includes("-h")) {
-  console.log(`
-📖 Pnpm Link Update Script
-
-Usage:
-  node update-links.js [version-type] [options]
-
-Arguments:
-  version-type    Version bump type: patch (default), minor, major
-
-Options:
-  --skip-version  Skip version update
-  --skip-build    Skip build step
-  --help, -h      Show this help message
-
-Examples:
-  node update-links.js              # Patch version update with build
-  node update-links.js minor        # Minor version update with build
-  node update-links.js --skip-build # Update links without building
-  node update-links.js patch --skip-version --skip-build # Only update links
-
-Projects that will be updated:
-${CONSUMING_PROJECTS.map((p) => `  - ${p}`).join("\n")}
-  `);
-  process.exit(0);
-}
-
-main();