index.ts

#!/usr/bin/env bun

interface BackupConfig {
  postgres: {
    connectionString: string;
  };
  s3: {
    region: string;
    bucket: string;
    accessKeyId: string;
    secretAccessKey: string;
    endpoint?: string;
  };
  backup: {
    retentionDays: number;
    compressionLevel: number;
  };
}

class PostgreSQLBackupManager {
  private config: BackupConfig;
  private backupDir: string;

  constructor(config: BackupConfig) {
    this.config = config;
    this.backupDir = "./backups";
  }

  private async ensureBackupDirectory(): Promise<void> {
    const backupDirExists = await Bun.file(this.backupDir).exists();
    if (!backupDirExists) {
      await Bun.write(`${this.backupDir}/.gitkeep`, "");
    }
  }

  async createBackup(): Promise<string> {
    await this.ensureBackupDirectory();

    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
    const backupFileName = `postgres-backup-${timestamp}.sql`;
    const backupPath = `${this.backupDir}/${backupFileName}`;

    console.log(`Creating backup: ${backupFileName}`);

    try {
      const pgDumpCommand = [
        "pg_dump",
        this.config.postgres.connectionString,
        "--verbose",
        "--clean",
        "--if-exists",
        "--create",
        "--format=custom",
        "--file",
        backupPath,
      ];

      const proc = Bun.spawn(pgDumpCommand, {
        stdout: "pipe",
        stderr: "pipe",
      });

      const exitCode = await proc.exited;

      if (exitCode !== 0) {
        const stderr = await new Response(proc.stderr).text();
        throw new Error(`pg_dump failed with exit code ${exitCode}: ${stderr}`);
      }

      console.log(`✅ Backup created: ${backupPath}`);
      return backupPath;
    } catch (error) {
      console.error(`❌ Backup failed:`, error);
      throw error;
    }
  }

  async compressBackup(filePath: string): Promise<string> {
    console.log(`Compressing: ${filePath}`);

    try {
      const file = Bun.file(filePath);
      const content = await file.arrayBuffer();

      const level = Math.max(
        0,
        Math.min(9, this.config.backup.compressionLevel)
      ) as 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
      const compressed = Bun.gzipSync(new Uint8Array(content), { level });

      const compressedPath = `${filePath}.gz`;
      await Bun.write(compressedPath, compressed);

      const proc = Bun.spawn(["rm", filePath], {
        stdout: "pipe",
        stderr: "pipe",
      });
      await proc.exited;

      console.log(`✅ Compressed: ${compressedPath}`);
      return compressedPath;
    } catch (error) {
      console.error(`❌ Compression failed:`, error);
      throw error;
    }
  }

  async uploadToS3(filePath: string): Promise<void> {
    console.log(`Uploading to S3: ${filePath}`);

    try {
      const fileName = filePath.split("/").pop()!;
      const s3Key = `private/postgres-backups/${new Date().getFullYear()}/${String(
        new Date().getMonth() + 1
      ).padStart(2, "0")}/${fileName}`;

      const s3Client = new Bun.S3Client({
        region: this.config.s3.region,
        accessKeyId: this.config.s3.accessKeyId,
        secretAccessKey: this.config.s3.secretAccessKey,
        bucket: this.config.s3.bucket,
        endpoint: this.config.s3.endpoint,
      });

      const file = Bun.file(filePath);
      await s3Client.write(s3Key, file, { type: "application/gzip" });

      console.log(`✅ Uploaded: s3://${this.config.s3.bucket}/${s3Key}`);
    } catch (error) {
      console.error(`❌ S3 upload failed:`, error);
      throw error;
    }
  }

  async cleanupOldBackups(): Promise<void> {
    console.log("🧹 Starting cleanup of old backups...");

    await this.cleanupLocalBackups();
    await this.cleanupS3Backups();
  }

  private async cleanupLocalBackups(): Promise<void> {
    try {
      if (!(await Bun.file(this.backupDir).exists())) {
        console.log("No local backup directory found, skipping local cleanup");
        return;
      }

      const entries = await Array.fromAsync(
        new Bun.Glob("*.gz").scan({ cwd: this.backupDir })
      );
      const cutoffDate = new Date();
      cutoffDate.setDate(
        cutoffDate.getDate() - this.config.backup.retentionDays
      );

      let deletedCount = 0;
      for (const file of entries) {
        const filePath = `${this.backupDir}/${file}`;
        const fileInfo = await Bun.file(filePath).exists();

        if (fileInfo) {
          const dateMatch = file.match(
            /postgres-backup-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})/
          );
          if (dateMatch && dateMatch[1]) {
            const fileDate = new Date(
              dateMatch[1].replace(/-/g, ":").replace("T", " ")
            );

            if (fileDate < cutoffDate) {
              const proc = Bun.spawn(["rm", filePath], {
                stdout: "pipe",
                stderr: "pipe",
              });
              await proc.exited;
              console.log(`🗑️  Removed old local backup: ${file}`);
              deletedCount++;
            }
          }
        }
      }

      if (deletedCount > 0) {
        console.log(`✅ Deleted ${deletedCount} old local backup(s)`);
      } else {
        console.log("No old local backups to delete");
      }
    } catch (error) {
      console.error(`❌ Local cleanup failed:`, error);
    }
  }

  private async cleanupS3Backups(): Promise<void> {
    try {
      console.log("🔍 Checking S3 bucket for old backups...");

      const s3Client = new Bun.S3Client({
        region: this.config.s3.region,
        accessKeyId: this.config.s3.accessKeyId,
        secretAccessKey: this.config.s3.secretAccessKey,
        bucket: this.config.s3.bucket,
        endpoint: this.config.s3.endpoint,
      });

      const cutoffDate = new Date();
      cutoffDate.setDate(
        cutoffDate.getDate() - this.config.backup.retentionDays
      );

      const prefix = "private/postgres-backups/";
      const response = await s3Client.list({ prefix });

      let deletedCount = 0;
      for (const obj of response.contents || []) {
        if (!obj.key) continue;

        const fileName = obj.key.split("/").pop();
        if (!fileName) continue;

        const dateMatch = fileName.match(
          /postgres-backup-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})/
        );

        if (dateMatch && dateMatch[1]) {
          const fileDate = new Date(
            dateMatch[1].replace(/-/g, ":").replace("T", " ")
          );

          if (fileDate < cutoffDate) {
            await s3Client.delete(obj.key);
            console.log(`🗑️  Removed old S3 backup: ${obj.key}`);
            deletedCount++;
          }
        }
      }

      if (deletedCount > 0) {
        console.log(`✅ Deleted ${deletedCount} old S3 backup(s)`);
      } else {
        console.log("No old S3 backups to delete");
      }
    } catch (error) {
      console.error(`❌ S3 cleanup failed:`, error);
    }
  }

  async performBackup(): Promise<void> {
    const startTime = new Date().toISOString();
    console.log(`Starting backup: ${startTime}`);

    try {
      const backupPath = await this.createBackup();
      const compressedPath = await this.compressBackup(backupPath);
      await this.uploadToS3(compressedPath);
      await this.cleanupOldBackups();

      console.log(`✅ Backup completed: ${new Date().toISOString()}`);
    } catch (error) {
      console.error(`❌ Backup failed:`, error);
      process.exit(1);
    }
  }

  async testConnection(): Promise<boolean> {
    try {
      const proc = Bun.spawn(
        ["pg_isready", "-d", this.config.postgres.connectionString],
        { stdout: "pipe", stderr: "pipe" }
      );

      const exitCode = await proc.exited;
      return exitCode === 0;
    } catch (error) {
      console.error(`❌ Connection test failed:`, error);
      return false;
    }
  }
}

function loadConfig(): BackupConfig {
  const connectionString = process.env.DATABASE_URL;
  console.log("connection string", connectionString);
  const region = process.env.AWS_REGION || process.env.S3_REGION;
  const bucket = process.env.S3_BUCKET;
  const accessKeyId = process.env.S3_ACCESS_KEY_ID;
  const secretAccessKey = process.env.S3_SECRET_ACCESS_KEY;

  if (!connectionString) {
    throw new Error("Missing DATABASE_URL or POSTGRES_CONNECTION_STRING");
  }
  if (!region) {
    throw new Error("Missing AWS_REGION or S3_REGION");
  }
  if (!bucket) {
    throw new Error("Missing S3_BUCKET");
  }
  if (!accessKeyId) {
    throw new Error("Missing S3_ACCESS_KEY_ID");
  }
  if (!secretAccessKey) {
    throw new Error("Missing S3_SECRET_ACCESS_KEY");
  }

  return {
    postgres: { connectionString },
    s3: {
      region,
      bucket,
      accessKeyId,
      secretAccessKey,
      endpoint: process.env.S3_ENDPOINT,
    },
    backup: {
      retentionDays: parseInt(process.env.BACKUP_RETENTION_DAYS || "30"),
      compressionLevel: parseInt(process.env.COMPRESSION_LEVEL || "6"),
    },
  };
}

async function main(): Promise<void> {
  try {
    const config = loadConfig();
    const backupManager = new PostgreSQLBackupManager(config);

    const isConnected = await backupManager.testConnection();
    if (!isConnected) {
      console.error("❌ Database connection failed");
      process.exit(1);
    }

    await backupManager.performBackup();
  } catch (error) {
    console.error("❌ System failed:", error);
    process.exit(1);
  }
}

if (import.meta.main) {
  main().catch((error) => {
    console.error("❌ Fatal error:", error);
    process.exit(1);
  });
}