zync-nest-data-module 1.1.38 → 1.1.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zync-nest-data-module",
-  "version": "1.1.38",
+  "version": "1.1.39",
   "description": "NestJS database module with database backup and file upload utilities",
   "keywords": [
     "nestjs",
@@ -23,7 +23,7 @@
     "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/",
+    "publish:npm": "npm publish",
     "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",
@@ -70,7 +70,7 @@
     "slugify": "^1.6.6",
     "uuid": "^11.1.0",
     "xlsx": "^0.18.5",
-    "zync-nest-library": "^1.0.30"
+    "zync-nest-library": "^1.0.38"
   },
   "devDependencies": {
     "@nestjs/cli": "^11.0.10",
@@ -103,6 +103,5 @@
   "packageManager": "pnpm@10.14.0",
   "publishConfig": {
     "access": "public"
-  },
-  "registry": "https://registry.asynctechs.com"
+  }
 }

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../libs/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,6CAA2B;AAC3B,4CAA0B;AAC1B,yCAAuB;AACvB,0CAAwB"}

package/libs/src/app.controller.ts

@@ -1,91 +0,0 @@
-import { Body, Controller, Get, Param, Post, Query } from "@nestjs/common";
-import { ApiOperation, ApiParam, ApiQuery, ApiResponse, ApiTags } from "@nestjs/swagger";
-
-@ApiTags("Test")
-@Controller("test")
-export class AppController {
-  @Get()
-  @ApiOperation({ summary: "Get test message" })
-  @ApiResponse({ status: 200, description: "Returns a test message" })
-  getTest(): { message: string; timestamp: string } {
-    return {
-      message: "Zync Nest Library is working!",
-      timestamp: new Date().toISOString()
-    };
-  }
-
-  @Get("health")
-  @ApiOperation({ summary: "Health check endpoint" })
-  @ApiResponse({ status: 200, description: "Returns health status" })
-  getHealth(): { status: string; uptime: number } {
-    return {
-      status: "healthy",
-      uptime: process.uptime()
-    };
-  }
-
-  @Post("echo")
-  @ApiOperation({ summary: "Echo back the request body" })
-  @ApiResponse({ status: 201, description: "Returns the echoed data" })
-  echoData(@Body() data: any): { echo: any; receivedAt: string } {
-    return {
-      echo: data,
-      receivedAt: new Date().toISOString()
-    };
-  }
-
-  @Get("params/:id")
-  @ApiOperation({ summary: "Test path parameters" })
-  @ApiParam({ name: "id", description: "Test ID" })
-  @ApiQuery({ name: "query", required: false, description: "Optional query parameter" })
-  @ApiResponse({ status: 200, description: "Returns parameter data" })
-  testParams(
-    @Param("id") id: string,
-    @Query("query") query?: string
-  ): { id: string; query?: string; timestamp: string } {
-    return {
-      id,
-      query,
-      timestamp: new Date().toISOString()
-    };
-  }
-
-  @Get("library-info")
-  @ApiOperation({ summary: "Get library information" })
-  @ApiResponse({ status: 200, description: "Returns library information" })
-  getLibraryInfo(): {
-    name: string;
-    version: string;
-    description: string;
-    modules: string[];
-  } {
-    return {
-      name: "zync-nest-library",
-      version: "1.0.23",
-      description: "NestJS library with database backup and file upload utilities",
-      modules: [
-        "billplz",
-        "dbbackup",
-        "exabytes",
-        "firebase",
-        "googleapi",
-        "htmlConverter",
-        "mailer",
-        "message",
-        "razorpay",
-        "senangpay",
-        "ultramsg",
-        "upload",
-        "utils",
-        "xlsx"
-      ]
-    };
-  }
-
-  @Get("redis-keys")
-  @ApiOperation({ summary: "Get all Redis keys" })
-  @ApiResponse({ status: 200, description: "Returns all Redis keys" })
-  getRedisKeys(): Promise<string[]> {
-    return Promise.resolve([]);
-  }
-}

package/libs/src/app.module.ts

@@ -1,34 +0,0 @@
-import { ApolloDriver, ApolloDriverConfig } from "@nestjs/apollo";
-import { Module, OnModuleInit } from "@nestjs/common";
-import { GraphQLModule } from "@nestjs/graphql";
-import { join } from "path";
-import { AppController } from "./app.controller";
-import { DbBackupModule, DbBackupService } from "./backup";
-import { RedisModule } from "./redis";
-import { TestModule } from "./test/test.module";
-import { ApScalarModule } from "zync-nest-library";
-import { MongooseModule } from "@nestjs/mongoose";
-
-@Module({
-  imports: [
-    RedisModule,
-    TestModule,
-    ApScalarModule,
-    MongooseModule.forRoot(process.env.mongodb_url),
-    GraphQLModule.forRoot<ApolloDriverConfig>({
-      driver: ApolloDriver,
-      autoSchemaFile: join(process.cwd(), "src/schema.gql"),
-      subscriptions: {
-        "graphql-ws": true,
-        "subscriptions-transport-ws": true
-      },
-      playground: true,
-      plugins: [],
-      context: ({ req, res }) => ({ req, res })
-    }),
-    DbBackupModule
-  ],
-  controllers: [AppController],
-  exports: [DbBackupModule, ApScalarModule]
-})
-export class ZyncNestDataModule {}

package/libs/src/backup/backup.config.ts

@@ -1,45 +0,0 @@
-import { Injectable } from "@nestjs/common";
-
-import * as dotenv from "dotenv";
-import { IDbBackupConfig } from "./backup.interface";
-import * as Path from "path";
-
-dotenv.config();
-
-@Injectable()
-export class DbBackupConfigService {
-  public getBackupConfig(): IDbBackupConfig {
-    const isDocker =
-      process.env.NODE_ENV === "production" || process.env.is_docker === "true";
-
-    return {
-      env: process.env.app_env || "",
-      mongodb: {
-        connectionStrings: process.env.mongodb_backup_connection_strings
-          ? process.env.mongodb_backup_connection_strings.split(",")
-          : [process.env.mongodb_url || ""],
-      },
-      backup: {
-        enabled: process.env.db_backup_enabled === "true",
-        dir: isDocker
-          ? process.env.db_backup_dir || "/app/backups"
-          : process.env.db_backup_dir
-          ? Path.join(__dirname, "..", "..", "..", "..", process.env.db_backup_dir)
-          : Path.join(__dirname, "..", "..", "..", "..", "db_backups"),
-        maxBackups: parseInt(process.env.db_backup_max || "10", 10),
-        isDownload: false, // download to false if upload to space is true
-        uploadToSpace: true, // upload to space to true if download is false
-      },
-      spaces: {
-        name: process.env.aws_bucket || "",
-        region: process.env.aws_s3_region || "nyc3",
-        key: process.env.aws_access_key_id || "",
-        secret: process.env.aws_secret_access_key || "",
-        dir: process.env.s3_spaces_dir || "db-backups",
-        endpoint:
-          process.env.s3_spaces_endpoint ||
-          "https://sgp1.digitaloceanspaces.com",
-      },
-    };
-  }
-}

package/libs/src/backup/backup.interface.ts

@@ -1,21 +0,0 @@
-export interface IDbBackupConfig {
-  env: string;
-  mongodb: {
-    connectionStrings: string | string[];
-  };
-  backup: {
-    dir: string;
-    enabled: boolean;
-    maxBackups: number;
-    isDownload: boolean;
-    uploadToSpace: boolean;
-  };
-  spaces: {
-    name: string;
-    region: string;
-    key: string;
-    secret: string;
-    endpoint: string;
-    dir?: string;
-  };
-}

package/libs/src/backup/backup.module.ts

@@ -1,11 +0,0 @@
-import { Module } from "@nestjs/common";
-import { DbBackupService } from "./backup.service";
-import { DbBackupConfigService } from "./backup.config";
-import { ApUploadModule } from "zync-nest-library";
-
-@Module({
-  imports: [ApUploadModule],
-  providers: [DbBackupService, DbBackupConfigService],
-  exports: [DbBackupService, DbBackupConfigService]
-})
-export class DbBackupModule {}

package/libs/src/backup/backup.service.ts

@@ -1,274 +0,0 @@
-import { Injectable, Logger } from "@nestjs/common";
-import { exec } from "child_process";
-import { promises as fs } from "fs";
-import * as path from "path";
-import { promisify } from "util";
-import { UploadService } from "zync-nest-library";
-import { DbBackupConfigService } from "./backup.config";
-import { IDbBackupConfig } from "./backup.interface";
-import { Cron, CronExpression } from "@nestjs/schedule";
-import { join } from "path";
-import { Worker } from "worker_threads";
-
-const execAsync = promisify(exec);
-
-@Injectable()
-export class DbBackupService {
-  private readonly logger = new Logger(DbBackupService.name);
-
-  constructor(private readonly dbConfigService: DbBackupConfigService, private readonly uploadService: UploadService) {}
-
-  public async runBackup(): Promise<any> {
-
-    console.log("[DB Backup] Log 1 Starting backup...");
-
-    const config = this.dbConfigService.getBackupConfig();
-
-    if (!config?.backup?.enabled) {
-      return;
-    }
-
-    console.log("[DB Backup] Log 2 Config:", config);
-
-    const backup = await this.createBackup(this.dbConfigService.getBackupConfig());
-
-    console.log("[DB Backup] Log 3 Backup:", backup);
-
-    return backup;
-  }
-
-  @Cron(CronExpression.EVERY_30_MINUTES)
-  public async runBackupWorker(): Promise<any> {
-
-    console.log("[DB Backup] Log 4 Running backup worker...");
-    
-    return new Promise((resolve, reject) => {
-      // 👇 Path to the compiled worker file (dist folder after build)
-      const workerPath = join(__dirname, "backup.worker.js");
-
-      console.log("Worker path:", workerPath);
-
-      const worker = new Worker(workerPath);
-
-      worker.on("message", (msg) => {
-        this.logger.log(`Worker finished: ${JSON.stringify(msg)}`);
-        resolve(void 0);
-      });
-
-      worker.on("error", (err) => {
-        this.logger.error(`Worker error: ${err.message}`);
-        reject(err);
-      });
-
-      worker.on("exit", (code) => {
-        if (code !== 0) this.logger.warn(`Worker exited with code ${code}`);
-      });
-    });
-  }
-
-  public async createBackup(options: IDbBackupConfig): Promise<any> {
-    try {
-      // Validate configuration before starting backup
-      this.validateBackupOptions(options);
-
-      // Create backup directory if it doesn't exist
-      await this.ensureDirectoryExists(options.backup.dir);
-
-      console.log("Starting backup process...", options.mongodb);
-
-      for (const connectionString of options.mongodb.connectionStrings) {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-
-        const dbName = this.parseConnectionStringDatabase(connectionString);
-
-        if (!dbName) {
-          this.logger.warn(`No valid database name found in connection string: ${connectionString}`);
-          continue;
-        }
-
-        this.logger.log(`Creating backup for database: ${dbName}`);
-
-        const backupFileName = `${process.env.app_name || "dev"}_${dbName}_backup_${timestamp}.tar.gz`;
-
-        const localBackupPath = path.join(
-          options.backup.dir,
-          `${process.env.app_name || "dev"}_${dbName}_backup_${timestamp}`
-        );
-        const localBackupFile = path.join(options.backup.dir, backupFileName);
-        // Ensure the local backup directory exists
-        await this.ensureDirectoryExists(localBackupPath);
-        // Create MongoDB dump
-        await this.createMongoDump(connectionString, localBackupPath);
-        // Compress the backup
-        await this.compressBackup(localBackupPath, localBackupFile);
-
-        if (options?.backup?.isDownload) {
-          return await fs.readFile(localBackupFile);
-        }
-
-        if (options?.backup?.uploadToSpace) {
-          await this.uploadToSpaces(options.spaces, backupFileName, localBackupFile);
-        }
-        // Upload to DigitalOcean Spaces
-        // Clean up
-        await this.cleanup(localBackupPath, options.backup.dir, options.backup.maxBackups);
-
-        this.logger.log(`Backup for ${dbName} completed: ${backupFileName}`);
-      }
-    } catch (error) {
-      this.logger.error(`Backup failed: ${error.message}`);
-      throw error;
-    }
-  }
-
-  private validateBackupOptions(options: IDbBackupConfig): void {
-    if (!options.mongodb?.connectionStrings) {
-      throw new Error("MongoDB connection strings are required");
-    }
-
-    const connectionStrings = Array.isArray(options.mongodb.connectionStrings)
-      ? options.mongodb.connectionStrings
-      : [options.mongodb.connectionStrings];
-
-    if (connectionStrings.length === 0 || connectionStrings.some((cs) => !cs || cs.trim() === "")) {
-      throw new Error("At least one valid MongoDB connection string is required");
-    }
-
-    if (options?.backup?.uploadToSpace) {
-      if (!options.spaces) {
-        throw new Error("DigitalOcean Spaces configuration is required");
-      }
-
-      if (!options.spaces.name || !options.spaces.key || !options.spaces.secret || !options.spaces.endpoint) {
-        throw new Error(
-          "DigitalOcean Spaces configuration is incomplete (name, key, secret, endpoint are all required)"
-        );
-      }
-    }
-
-    if (!options.backup?.dir) {
-      throw new Error("Backup directory is required");
-    }
-  }
-
-  private async ensureDirectoryExists(dir: string): Promise<void> {
-    try {
-      await fs.mkdir(dir, { recursive: true });
-    } catch (error) {
-      if (error.code !== "EEXIST") {
-        throw error;
-      }
-    }
-  }
-
-  private async createMongoDump(connectionString: string, outputPath: string): Promise<void> {
-    this.logger.log("Creating MongoDB dump...");
-
-    if (!connectionString) {
-      throw new Error("Connection string is required for MongoDB backup");
-    }
-
-    await execAsync(`mongodump --uri "${connectionString}" --out ${outputPath}`);
-  }
-
-  private async compressBackup(sourcePath: string, destinationFile: string): Promise<void> {
-    this.logger.log("Compressing backup...");
-    await execAsync(`tar -czvf ${destinationFile} -C ${sourcePath} .`);
-  }
-
-  private async uploadToSpaces(
-    spacesConfig: IDbBackupConfig["spaces"],
-    fileName: string,
-    filePath: string
-  ): Promise<void> {
-    this.logger.log("Uploading to DigitalOcean Spaces...");
-
-    // Validate required spaces configuration
-    if (!spacesConfig.name) {
-      throw new Error("DigitalOcean Spaces bucket name is required");
-    }
-    if (!spacesConfig.key) {
-      throw new Error("DigitalOcean Spaces access key is required");
-    }
-    if (!spacesConfig.secret) {
-      throw new Error("DigitalOcean Spaces secret key is required");
-    }
-    if (!spacesConfig.endpoint) {
-      throw new Error("DigitalOcean Spaces endpoint is required");
-    }
-
-    // Ensure endpoint is a proper URL
-    let endpoint = spacesConfig.endpoint;
-    if (endpoint && !endpoint.startsWith("http://") && !endpoint.startsWith("https://")) {
-      endpoint = `https://${endpoint}`;
-    }
-
-    const fileContent = await fs.readFile(filePath);
-
-    await this.uploadService.upload.uploadBuffer({
-      file: fileContent,
-      filename: fileName,
-      disableTransformName: true,
-      filetype: "application/gzip",
-      dir: spacesConfig.dir || "db-backups"
-    });
-  }
-
-  private async cleanup(backupPath: string, backupDir: string, maxBackups: number): Promise<void> {
-    this.logger.log("Cleaning up...");
-
-    // Remove the uncompressed backup
-    await fs.rm(backupPath, { recursive: true, force: true });
-
-    // Remove old backups
-    this.cleanupBackups();
-  }
-
-  public async cleanupBackups(): Promise<void> {
-    this.logger.log("Cleaning up...");
-
-    const { backup } = this.dbConfigService.getBackupConfig();
-
-    // Remove old backups
-    const files = await fs.readdir(backup.dir);
-
-    const backupFiles = files
-      .filter((file) => file.endsWith(".tar.gz"))
-      .sort()
-      .reverse();
-
-    if (backupFiles.length > backup.maxBackups) {
-      const toDelete = backupFiles.slice(backup.maxBackups);
-      for (const file of toDelete) {
-        console.log(file, "files to delete");
-        console.log(file?.replace(".tar.gz", ""), "files to delete");
-
-        await fs.unlink(path.join(backup.dir, file));
-        await fs.rm(path.join(backup.dir, file?.replace(".tar.gz", "")), {
-          recursive: true,
-          force: true
-        });
-      }
-      this.logger.log(`Removed ${toDelete.length} old backup(s)`);
-    }
-  }
-
-  private parseConnectionStringDatabase(connectionString: string): string | null {
-    try {
-      // Remove any authentication info and query parameters for parsing
-      const cleanUri = connectionString.replace(/^mongodb(\+srv)?:\/\//, "");
-
-      // Find the database name after the last slash and before any query parameters
-      const dbMatch = cleanUri.match(/\/([^/?&]+)(\?|$)/);
-
-      if (dbMatch && dbMatch[1] && dbMatch[1] !== "admin" && dbMatch[1] !== "test") {
-        return dbMatch[1];
-      }
-
-      return null;
-    } catch (error) {
-      this.logger.warn(`Failed to parse database from connection string: ${error.message}`);
-      return null;
-    }
-  }
-}

package/libs/src/backup/backup.worker.ts

@@ -1,35 +0,0 @@
-import { Module } from "@nestjs/common";
-import { NestFactory } from "@nestjs/core";
-import { MongooseModule } from "@nestjs/mongoose";
-import { WinstonModule } from "nest-winston";
-import { isMainThread, parentPort } from "worker_threads";
-import { DbBackupModule } from "./backup.module";
-import { DbBackupService } from "./backup.service";
-
-@Module({
-  imports: [MongooseModule.forRoot(process.env.mongodb_url), DbBackupModule, WinstonModule.forRoot({})],
-  providers: [],
-  exports: []
-})
-class BackupWorkerModule {}
-
-async function bootstrap() {
-  console.log("[Sales Worker] Bootstrap started");
-
-  try {
-    const app = await NestFactory.createApplicationContext(BackupWorkerModule, {});
-    const backupService = app.get(DbBackupService);
-
-    await backupService.runBackup();
-
-    parentPort?.postMessage({ status: "completed" });
-    await app.close();
-    process.exit(0);
-  } catch (error) {
-    console.error("[Sales Worker] Error:", error);
-    parentPort?.postMessage({ status: "error", message: error?.message, stack: error?.stack });
-    process.exit(1);
-  }
-}
-
-if (!isMainThread) bootstrap();

package/libs/src/backup/index.ts

@@ -1,4 +0,0 @@
-export * from "./backup.module";
-export * from "./backup.service";
-export * from "./backup.config";
-export * from "./backup.interface";

package/libs/src/base/dto.ts

@@ -1,46 +0,0 @@
-import { Field, ID, InputType, ObjectType } from "@nestjs/graphql";
-
-@ObjectType()
-export class BaseDto {
-  @Field(() => ID)
-  _id: string;
-
-  @Field({ nullable: true })
-  key?: string;
-
-  @Field({ nullable: true })
-  ref: string;
-  @Field(() => String, { nullable: true })
-  refId: string;
-  @Field({ nullable: true })
-  createdAt: number;
-  @Field({ nullable: true })
-  createdBy: string;
-  @Field({ nullable: true })
-  updatedAt: number;
-  @Field({ nullable: true })
-  updatedBy: string;
-
-  @Field({ nullable: true })
-  canDelete: boolean;
-
-  @Field({ nullable: true })
-  canUpdate: boolean;
-}
-
-
-@InputType()
-export class BasePageInput {
-  @Field((type) => Number, { nullable: false })
-  skip: number;
-  @Field((type) => Number, { nullable: false })
-  take: number;
-  @Field((type) => String, { nullable: true })
-  keyword: string;
-
-  @Field((type) => Number, { nullable: true })
-  fromDate: number;
-
-  @Field((type) => Number, { nullable: true })
-  toDate: number;
-}

package/libs/src/base/index.ts

@@ -1,2 +0,0 @@
-export * from "./dto";
-export * from "./resolver";

package/libs/src/base/resolver.ts

@@ -1,20 +0,0 @@
-import { Parent, ResolveField, Resolver } from "@nestjs/graphql";
-import { BaseDto } from "./dto";
-
-@Resolver((of) => BaseDto)
-export class ApBaseResolver<T extends BaseDto> {
-  @ResolveField((of) => String, { name: "key" })
-  public async key(@Parent() parent: BaseDto) {
-    return parent?.key || parent?._id;
-  }
-
-  @ResolveField((of) => Boolean, { name: "canUpdate" })
-  public async canUpdate(@Parent() parent: BaseDto) {
-    return parent.canUpdate == undefined ? true : parent.canUpdate;
-  }
-
-  @ResolveField((of) => Boolean, { name: "canDelete" })
-  public async canDelete(@Parent() parent: BaseDto) {
-    return parent.canDelete == undefined ? true : parent.canDelete;
-  }
-}

package/libs/src/database/database.module.ts

@@ -1,28 +0,0 @@
-import { DynamicModule, Module } from "@nestjs/common";
-import { ModelDefinition, MongooseModule } from "@nestjs/mongoose";
-import { DatabaseService } from "./database.service";
-import { TransactionManager } from "./database.transaction";
-import { ApUniqueIdGenerator, UniqueId, UniqueIdSchema } from "./database.uniqueId";
-
-export const CONNECTION_NAME = "ZYNC_DB_CONNECTION_NAME";
-
-@Module({})
-export class DatabaseModule {
-  static forFeature(models: ModelDefinition[], connectionName?: string): DynamicModule {
-    const MongooseModuleForFeature = connectionName
-      ? MongooseModule.forFeature([...models, { name: UniqueId.name, schema: UniqueIdSchema }], connectionName)
-      : MongooseModule.forFeature([...models, { name: UniqueId.name, schema: UniqueIdSchema }]);
-
-    return {
-      module: DatabaseModule,
-      imports: [MongooseModuleForFeature],
-      providers: [
-        { provide: CONNECTION_NAME, useValue: connectionName },
-        TransactionManager,
-        ApUniqueIdGenerator,
-        DatabaseService
-      ],
-      exports: [MongooseModule, TransactionManager, ApUniqueIdGenerator, DatabaseService]
-    };
-  }
-}