feat: Introduce backup and restore for postgres

app/client/packages/rts/src/ctl/backup/backup.test.ts

@@ -8,6 +8,7 @@ import {
   encryptBackupArchive,
   executeCopyCMD,
   executeMongoDumpCMD,
+  executePostgresDumpCMD,
   getAvailableBackupSpaceInBytes,
   getEncryptionPasswordFromUser,
   getGitRoot,
@@ -66,6 +67,17 @@ describe("Backup Tests", () => {
     console.log(res);
   });
 
+  test("Test postgres dump CMD generation", async () => {
+    const dest = "/dest";
+    const url = "postgresql://username:password@host/appsmith";
+    const cmd =
+      "pg_dump postgresql://username:password@host/appsmith --schema=appsmith --format=custom --file=/dest/pg-data";
+    const res = await executePostgresDumpCMD(dest, url);
+
+    expect(res).toBe(cmd);
+    console.log(res);
+  });
+
   test("Test get gitRoot path when APPSMITH_GIT_ROOT is '' ", () => {
     expect(getGitRoot("")).toBe("/appsmith-stacks/git-storage");
   });
@@ -246,7 +258,7 @@ test("Get DB name from Mongo URI 1", async () => {
   const mongodb_uri =
     "mongodb+srv://admin:[email protected]/my_db_name?retryWrites=true&minPoolSize=1&maxPoolSize=10&maxIdleTimeMS=900000&authSource=admin";
   const expectedDBName = "my_db_name";
-  const dbName = utils.getDatabaseNameFromMongoURI(mongodb_uri);
+  const dbName = utils.getDatabaseNameFromUrl(mongodb_uri);
 
   expect(dbName).toEqual(expectedDBName);
 });
@@ -255,7 +267,7 @@ test("Get DB name from Mongo URI 2", async () => {
   const mongodb_uri =
     "mongodb+srv://admin:[email protected]/test123?retryWrites=true&minPoolSize=1&maxPoolSize=10&maxIdleTimeMS=900000&authSource=admin";
   const expectedDBName = "test123";
-  const dbName = utils.getDatabaseNameFromMongoURI(mongodb_uri);
+  const dbName = utils.getDatabaseNameFromUrl(mongodb_uri);
 
   expect(dbName).toEqual(expectedDBName);
 });
@@ -264,15 +276,30 @@ test("Get DB name from Mongo URI 3", async () => {
   const mongodb_uri =
     "mongodb+srv://admin:[email protected]/test123";
   const expectedDBName = "test123";
-  const dbName = utils.getDatabaseNameFromMongoURI(mongodb_uri);
+  const dbName = utils.getDatabaseNameFromUrl(mongodb_uri);
 
   expect(dbName).toEqual(expectedDBName);
 });
 
 test("Get DB name from Mongo URI 4", async () => {
   const mongodb_uri = "mongodb://appsmith:pAssW0rd!@localhost:27017/appsmith";
   const expectedDBName = "appsmith";
-  const dbName = utils.getDatabaseNameFromMongoURI(mongodb_uri);
+  const dbName = utils.getDatabaseNameFromUrl(mongodb_uri);
 
   expect(dbName).toEqual(expectedDBName);
 });
+test("Get DB name from Postgres URL", async () => {
+  const dbName = utils.getDatabaseNameFromUrl(
+    "postgresql://user:password@host:5432/postgres_db",
+  );
+
+  expect(dbName).toEqual("postgres_db");
+});
+
+test("Get DB name from Postgres URL with query params", async () => {
+  const dbName = utils.getDatabaseNameFromUrl(
+    "postgresql://user:password@host:5432/postgres_db?sslmode=disable",
+  );
+
+  expect(dbName).toEqual("postgres_db");
+});

app/client/packages/rts/src/ctl/backup/index.ts

@@ -8,6 +8,15 @@ import * as linkClasses from "./links";
 import { BackupState } from "./BackupState";
 
 export async function run(args: string[]) {
+  const url = utils.getDburl();
+
+  if (!url.startsWith("mongodb") && !url.startsWith("postgresql")) {
+    console.error("Only MongoDB and Postgres databases are supported.");
+    process.exitCode = 1;
+
+    return;
+  }
+
   await utils.ensureSupervisorIsRunning();
 
   const state: BackupState = new BackupState(args);
@@ -17,6 +26,7 @@ export async function run(args: string[]) {
     new linkClasses.DiskSpaceLink(),
     new linkClasses.ManifestLink(state),
     new linkClasses.MongoDumpLink(state),
+    new linkClasses.PostgresDumpLink(state),
     new linkClasses.GitStorageLink(state),
     new linkClasses.EnvFileLink(state),
 

app/client/packages/rts/src/ctl/backup/links/ManifestLink.ts

@@ -14,7 +14,7 @@ export class ManifestLink implements Link {
     const version = await utils.getCurrentAppsmithVersion();
     const manifestData = {
       appsmithVersion: version,
-      dbName: utils.getDatabaseNameFromMongoURI(utils.getDburl()),
+      dbName: utils.getDatabaseNameFromUrl(utils.getDburl()),
     };
 
     await fsPromises.writeFile(

app/client/packages/rts/src/ctl/backup/links/MongoDumpLink.ts

@@ -9,9 +9,13 @@ export class MongoDumpLink implements Link {
   constructor(private readonly state: BackupState) {}
 
   async doBackup() {
-    console.log("Exporting database");
-    await executeMongoDumpCMD(this.state.backupRootPath, utils.getDburl());
-    console.log("Exporting database done.");
+    const url = utils.getDburl();
+
+    if (url.startsWith("mongodb")) {
+      console.log("Exporting database");
+      await executeMongoDumpCMD(this.state.backupRootPath, url);
+      console.log("Exporting database done.");
+    }
   }
 }
 

app/client/packages/rts/src/ctl/backup/links/PostgresDumpLink.ts

@@ -0,0 +1,33 @@
+import type { Link } from ".";
+import type { BackupState } from "../BackupState";
+import * as utils from "../../utils";
+
+/**
+ * Exports the Postgres database data using mongodump.
+ */
+export class PostgresDumpLink implements Link {
+  constructor(private readonly state: BackupState) {}
+
+  async doBackup() {
+    const url = utils.getDburl();
+
+    if (url.startsWith("postgresql")) {
+      console.log("Exporting database");
+      await executePostgresDumpCMD(this.state.backupRootPath, url);
+      console.log("Exporting database done.");
+    }
+  }
+}
+
+export async function executePostgresDumpCMD(
+  destFolder: string,
+  dbUrl: string,
+) {
+  return await utils.execCommand([
+    "pg_dump",
+    dbUrl,
+    "--schema=appsmith",
+    "--format=custom",
+    `--file=${destFolder}/pg-data`,
+  ]);
+}

app/client/packages/rts/src/ctl/backup/links/index.ts

@@ -16,3 +16,4 @@ export * from "./EnvFileLink";
 export * from "./GitStorageLink";
 export * from "./ManifestLink";
 export * from "./MongoDumpLink";
+export * from "./PostgresDumpLink";

app/client/packages/rts/src/ctl/restore.ts

@@ -111,6 +111,21 @@ async function extractArchive(backupFilePath: string, restoreRootPath: string) {
 
 async function restoreDatabase(restoreContentsPath: string, dbUrl: string) {
   console.log("Restoring database...");
+
+  if (dbUrl.startsWith("mongodb")) {
+    await restoreMongoDB(restoreContentsPath, dbUrl);
+  } else if (dbUrl.includes("postgresql")) {
+    await restorePostgres(restoreContentsPath, dbUrl);
+  } else {
+    throw new Error(
+      "Unsupported database type, only MongoDB and Postgres are supported",
+    );
+  }
+
+  console.log("Restoring database completed");
+}
+
+async function restoreMongoDB(restoreContentsPath: string, dbUrl: string) {
   const cmd = [
     "mongorestore",
     `--uri=${dbUrl}`,
@@ -121,7 +136,7 @@ async function restoreDatabase(restoreContentsPath: string, dbUrl: string) {
 
   try {
     const fromDbName = await getBackupDatabaseName(restoreContentsPath);
-    const toDbName = utils.getDatabaseNameFromMongoURI(dbUrl);
+    const toDbName = utils.getDatabaseNameFromUrl(dbUrl);
 
     console.log("Restoring database from " + fromDbName + " to " + toDbName);
     cmd.push(
@@ -139,6 +154,42 @@ async function restoreDatabase(restoreContentsPath: string, dbUrl: string) {
   console.log("Restoring database completed");
 }
 
+async function restorePostgres(restoreContentsPath: string, dbUrl: string) {
+  const cmd = [
+    "pg_restore",
+    "--verbose",
+    "--clean",
+    `${restoreContentsPath}/pg-data`,
+  ];
+  const url = new URL(dbUrl);
+  const isLocalhost = ["localhost", "127.0.0.1"].includes(url.hostname);
+
+  if (isLocalhost) {
+    let dbName: string;
+
+    try {
+      dbName = utils.getDatabaseNameFromUrl(dbUrl);
+      console.log("Restoring database to", dbName);
+    } catch (error) {
+      console.warn(
+        "Error reading manifest file. Assuming same database name as appsmith.",
+        error,
+      );
+      dbName = "appsmith";
+    }
+    cmd.push(
+      "-d",
+      "postgresql://localhost:5432/" + dbName,
+      // Use default user for local postgres
+      "--username=postgres",
+    );
+  } else {
+    cmd.push("-d", dbUrl);
+  }
+
+  await utils.execCommand(cmd);
+}
+
 async function restoreDockerEnvFile(
   restoreContentsPath: string,
   backupName: string,

app/client/packages/rts/src/ctl/utils.ts

@@ -249,8 +249,13 @@ export async function execCommandSilent(cmd, options?) {
   });
 }
 
-export function getDatabaseNameFromMongoURI(uri) {
-  const uriParts = uri.split("/");
-
-  return uriParts[uriParts.length - 1].split("?")[0];
+/**
+ * Extracts database name from MongoDB or Postgres connection URL
+ * @param url - Database connection URL
+ * @returns Database name
+ */
+export function getDatabaseNameFromUrl(url: string) {
+  const parts = url.split("/");
+
+  return parts[parts.length - 1].split("?")[0];
 }