zync-nest-data-module 1.0.0

package/libs/src/app.controller.ts

@@ -0,0 +1,84 @@
+import { Controller, Get, Post, Body, Param, Query } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse, ApiParam, ApiQuery } 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',
+      ],
+    };
+  }
+}

package/libs/src/app.module.ts

@@ -0,0 +1,31 @@
+import { ApolloDriver, ApolloDriverConfig } from "@nestjs/apollo";
+import { Module } from "@nestjs/common";
+import { GraphQLModule } from "@nestjs/graphql";
+import { join } from "path";
+import { AppController } from "./app.controller";
+import { ApDatabaseModule } from "./database";
+import { ApDbBackupModule } from "./backup";
+import { TestModule } from "./test/test.module";
+
+@Module({
+  imports: [
+    TestModule,
+    GraphQLModule.forRoot<ApolloDriverConfig>({
+      driver: ApolloDriver,
+      // csrfPrevention: false,
+      autoSchemaFile: join(process.cwd(), "src/schema.gql"),
+      subscriptions: {
+        "graphql-ws": true,
+        "subscriptions-transport-ws": true,
+      },
+      playground: true,
+      plugins: [],
+      context: ({ req, res }) => ({ req, res }),
+    }),
+    ApDatabaseModule,
+    ApDbBackupModule,
+  ],
+  controllers: [AppController],
+  exports: [ApDatabaseModule, ApDbBackupModule],
+})
+export class ApDbModule {}

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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,11 @@
+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 ApDbBackupModule {}

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

@@ -0,0 +1,283 @@
+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";
+
+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> {
+    const config = this.dbConfigService.getBackupConfig();
+
+    if (!config?.backup?.enabled) {
+      return;
+    }
+
+    return await this.createBackup(this.dbConfigService.getBackupConfig());
+  }
+
+  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/index.ts

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

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

@@ -0,0 +1,26 @@
+import { Global, Module } from "@nestjs/common";
+import { MongooseModule } from "@nestjs/mongoose";
+import { DatabaseService } from "./database.service";
+import { TransactionManager } from "./database.transaction";
+import {
+  ApUniqueIdGenerator,
+  UniqueId,
+  UniqueIdSchema,
+} from "./database.uniqueId";
+import { ConfigModule } from "@nestjs/config";
+
+console.log(process.env.mongodb_url,"db url");
+
+@Global()
+@Module({
+  imports: [
+    ConfigModule.forRoot(),
+    MongooseModule.forRoot(process.env.mongodb_url),
+    MongooseModule.forFeature([
+      { name: UniqueId.name, schema: UniqueIdSchema },
+    ]),
+  ],
+  providers: [TransactionManager, ApUniqueIdGenerator, DatabaseService],
+  exports: [ApUniqueIdGenerator, TransactionManager, DatabaseService],
+})
+export class ApDatabaseModule {}