@nocobase/plugin-backups 2.2.0-beta.1 → 2.2.0-beta.11

package/dist/server/adapters/database.js

@@ -48,26 +48,75 @@ var import_promises = require("stream/promises");
 var import_util = require("util");
 var import_utils = require("../utils");
 const exec = (0, import_util.promisify)(import_child_process.exec);
-const D$$ = import_os.default.platform() === "win32" ? "$$" : "\\$\\$";
 const STREAM_BUFFER_SIZE = 2 * 1024 * 1024;
 const run = async (command, envVars = {}) => {
   try {
-    const { stdout } = await exec(command, { env: { ...process.env, ...envVars } });
-    return stdout;
+    const result = await exec(command, { env: { ...process.env, ...envVars } });
+    if (typeof result === "string") {
+      return result;
+    }
+    if (result && typeof result === "object" && "stdout" in result) {
+      const { stdout } = result;
+      return typeof stdout === "string" ? stdout : String(stdout ?? "");
+    }
+    return "";
   } catch (error) {
     throw new Error(`${error.message}`);
   }
 };
+const runSpawn = async (command, args, envVars = {}) => {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)(command, args, {
+      env: { ...process.env, ...envVars },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdout = [];
+    const stderr = [];
+    let settled = false;
+    child.stdout.on("data", (chunk) => stdout.push(Buffer.from(chunk)));
+    child.stderr.on("data", (chunk) => stderr.push(Buffer.from(chunk)));
+    child.on("error", (error) => {
+      settled = true;
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      if (code === 0) {
+        settled = true;
+        resolve(Buffer.concat(stdout).toString());
+        return;
+      }
+      const errorMessage = Buffer.concat(stderr).toString().trim() || `${command} exited with code ${code}`;
+      settled = true;
+      reject(new Error(errorMessage));
+    });
+  });
+};
 const formatPathInEnv = (path2) => {
-  if (path2 && /\s/.test(path2) && !/^".*"$/.test(path2) && !/^'.*'$/.test(path2)) {
-    return `"${path2}"`;
+  if ((path2 == null ? void 0 : path2.startsWith('"')) && path2.endsWith('"') || (path2 == null ? void 0 : path2.startsWith("'")) && path2.endsWith("'")) {
+    return path2.slice(1, -1);
   }
   return path2;
 };
 const escapeStringLiteral = (value) => String(value).replace(/'/g, "''");
 const quotePgIdentifier = (value) => `"${String(value).replace(/"/g, '""')}"`;
-const quoteShellArg = (value) => `'${String(value).replace(/'/g, "'\\''")}'`;
-const quotePgTablePattern = (table) => quoteShellArg(String(table).split(".").map(quotePgIdentifier).join("."));
+const quotePgTablePattern = (table) => String(table).split(".").map(quotePgIdentifier).join(".");
+const isPgRestoreSchemaTocEntry = (line) => /^\d+;\s+\d+\s+\d+\s+SCHEMA\s+-\s+/.test(line);
+const parsePgTableReference = (table, defaultSchema) => {
+  const parts = String(table).split(".");
+  if (parts.length > 1) {
+    return {
+      schema: parts[0],
+      table: parts.slice(1).join(".")
+    };
+  }
+  return {
+    schema: defaultSchema,
+    table: parts[0]
+  };
+};
 const qualifyPgTablePattern = (table, schema) => {
   const tablePattern = String(table);
   if (!schema || tablePattern.includes(".")) {
@@ -75,6 +124,11 @@ const qualifyPgTablePattern = (table, schema) => {
   }
   return `${schema}.${tablePattern}`;
 };
+const assertPostgresSchemaIdentifier = (schema) => {
+  if (!/^[A-Za-z_][A-Za-z0-9_]{0,62}$/.test(schema)) {
+    throw new Error(`Invalid PostgreSQL schema: ${schema}`);
+  }
+};
 class BaseDBAdapter {
   constructor(dbOpts) {
     this.dbOpts = dbOpts;
@@ -84,14 +138,17 @@ class BaseDBAdapter {
   async clientVersion(_) {
   }
   assertCommand = (command) => {
-    try {
-      (0, import_child_process.execSync)(`${command} --version`);
-    } catch (error) {
+    const result = (0, import_child_process.spawnSync)(command, ["--version"], { encoding: "utf8" });
+    if (result.error || result.status !== 0) {
       throw new Error(
-        `Command ${command} not found, please install it first. Check reference here: https://docs.nocobase.com/handbook/backups#installation`
+        `Command ${command} not found, please install it first. Check reference here: https://docs.nocobase.com/ops-management/backup-manager/`
       );
     }
   };
+  hasCommand(command) {
+    const result = (0, import_child_process.spawnSync)(command, ["--version"], { encoding: "utf8" });
+    return !result.error && result.status === 0;
+  }
 }
 class MySQLAdapter extends BaseDBAdapter {
   #backupCmd = "mysqldump";
@@ -140,6 +197,7 @@ class MySQLAdapter extends BaseDBAdapter {
       "--set-gtid-purged=OFF",
       "--routines",
       "--triggers",
+      "--events",
       ...version && version > 7 ? ["--column-statistics=0"] : [],
       database
     ];
@@ -232,9 +290,47 @@ class MySQLAdapter extends BaseDBAdapter {
       return "";
     }
   }
-  async restore({ filePath, skipDropAllTables = false }) {
+  async restore({ filePath, skipDropAllTables = false, restoreMode }) {
     const { username, host, port, database, password } = this.dbOpts;
-    if (!skipDropAllTables) {
+    if (restoreMode === "preserveTables") {
+      const dropViewsCommand = `mysql -u ${username} -h ${host} ${port ? `-P ${port}` : ""} --protocol=tcp -D ${database} -e "
+    DELIMITER $$
+    DROP PROCEDURE IF EXISTS drop_all_views$$
+    CREATE PROCEDURE drop_all_views()
+    BEGIN
+        DECLARE _done INT DEFAULT FALSE;
+        DECLARE _viewName VARCHAR(255);
+
+        DECLARE _cursor CURSOR FOR
+            SELECT table_name
+            FROM information_schema.VIEWS
+            WHERE table_schema = SCHEMA();
+
+        DECLARE CONTINUE HANDLER FOR NOT FOUND SET _done = TRUE;
+
+        OPEN _cursor;
+
+        REPEAT
+            FETCH _cursor INTO _viewName;
+
+            IF NOT _done THEN
+                SET @stmt_sql = CONCAT('DROP VIEW IF EXISTS ', _viewName);
+                PREPARE stmt FROM @stmt_sql;
+                EXECUTE stmt;
+                DEALLOCATE PREPARE stmt;
+            END IF;
+
+        UNTIL _done END REPEAT;
+
+        CLOSE _cursor;
+    END$$
+
+    CALL drop_all_views()$$
+    DROP PROCEDURE drop_all_views$$
+    DELIMITER ;
+    "`;
+      await run(dropViewsCommand, { MYSQL_PWD: password });
+    } else if (!skipDropAllTables) {
       const dropDataCommand = `mysql -u ${username} -h ${host} ${port ? `-P ${port}` : ""} --protocol=tcp -D ${database} -e "
     DELIMITER $$
     DROP PROCEDURE IF EXISTS drop_all_tables_and_triggers$$
@@ -322,56 +418,167 @@ class MySQLAdapter extends BaseDBAdapter {
   }
 }
 class PostgresAdapter extends BaseDBAdapter {
-  get #backupCmd() {
+  get backupToolchain() {
+    return "postgres";
+  }
+  getBackupCommandName(_toolchain = this.backupToolchain) {
     return formatPathInEnv(process.env.PG_DUMP_PATH) || "pg_dump";
   }
-  get #restoreCmd() {
+  getRestoreCommandName(_toolchain = this.backupToolchain) {
     return formatPathInEnv(process.env.PG_RESTORE_PATH) || "pg_restore";
   }
+  getSqlCommandName(_toolchain = this.backupToolchain) {
+    return formatPathInEnv(process.env.PSQL_PATH) || "psql";
+  }
+  getPasswordEnvVars(password, _toolchain = this.backupToolchain) {
+    return { PGPASSWORD: password };
+  }
+  getBackupSchema() {
+    return this.dbOpts.schema;
+  }
   async check(op) {
     switch (op) {
       case "backup":
-        this.assertCommand(this.#backupCmd);
+        this.assertCommand(this.getBackupCommandName());
         break;
       case "restore":
-        this.assertCommand(this.#restoreCmd);
+        this.assertCommand(this.getRestoreCommandName());
         break;
     }
   }
   async clientVersion(op) {
-    const cmd = op === "backup" ? this.#backupCmd : this.#restoreCmd;
+    const cmd = op === "backup" ? this.getBackupCommandName() : this.getRestoreCommandName();
     try {
-      return (0, import_child_process.execSync)(`${cmd} --version`).toString();
+      return await runSpawn(cmd, ["--version"]);
     } catch (_error) {
       return void 0;
     }
   }
   async backup({ dir, includeTables, excludeTables }) {
-    const { username, host, port, database, password, schema: backupSchema } = this.dbOpts;
+    const { database, password } = this.dbOpts;
     const filePath = `${dir}/data`;
-    const schemaOption = backupSchema ? `--schema=${backupSchema}` : "";
-    const includeOption = Array.isArray(includeTables) && includeTables.length ? includeTables.map((table) => `-t ${quotePgTablePattern(qualifyPgTablePattern(table, backupSchema))}`).join(" ") : "";
-    const excludeOption = Array.isArray(excludeTables) && excludeTables.length ? excludeTables.map((table) => `-T ${quotePgTablePattern(qualifyPgTablePattern(table, backupSchema))}`).join(" ") : "";
-    const command = `${this.#backupCmd} ${includeOption} ${excludeOption} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -F c -b --quote-all-identifiers ${schemaOption} -f ${filePath} ${database}`;
-    await run(command, { PGPASSWORD: password });
+    const backupSchema = this.getBackupSchema();
+    const expandedExcludeTables = Array.isArray(excludeTables) ? [.../* @__PURE__ */ new Set([...excludeTables, ...await this.getOwnedSequenceTables(excludeTables, backupSchema)])] : [];
+    const includeArgs = Array.isArray(includeTables) && includeTables.length ? includeTables.flatMap((table) => ["-t", quotePgTablePattern(qualifyPgTablePattern(table, backupSchema))]) : [];
+    const excludeArgs = expandedExcludeTables.length ? expandedExcludeTables.flatMap((table) => [
+      "-T",
+      quotePgTablePattern(qualifyPgTablePattern(table, backupSchema))
+    ]) : [];
+    const args = [
+      ...includeArgs,
+      ...excludeArgs,
+      ...this.getConnectionArgs(false),
+      "-F",
+      "c",
+      "-b",
+      "--quote-all-identifiers",
+      ...backupSchema ? [`--schema=${backupSchema}`] : [],
+      "-f",
+      filePath,
+      database
+    ];
+    await runSpawn(this.getBackupCommandName(), args, this.getPasswordEnvVars(password));
   }
-  async restore({ filePath, schema, skipDropAllTables = false }) {
-    const { username, host, port, database, password } = this.dbOpts;
+  async getOwnedSequenceTables(excludeTables, backupSchema) {
+    if (!Array.isArray(excludeTables) || !excludeTables.length) {
+      return [];
+    }
+    const tableRefs = excludeTables.map((table) => parsePgTableReference(table, backupSchema)).filter((ref) => ref.table);
+    if (!tableRefs.length) {
+      return [];
+    }
+    const values = tableRefs.map((ref) => {
+      const schemaValue = ref.schema == null ? "NULL" : `'${escapeStringLiteral(ref.schema)}'`;
+      return `(${schemaValue}, '${escapeStringLiteral(ref.table)}')`;
+    }).join(",");
+    const query = `
+      WITH excluded(schema_name, table_name) AS (VALUES ${values})
+      SELECT seq_ns.nspname || '.' || seq.relname
+      FROM excluded
+      JOIN pg_class tbl ON tbl.relname = excluded.table_name
+      JOIN pg_namespace tbl_ns ON tbl_ns.oid = tbl.relnamespace
+      JOIN pg_depend dep ON dep.refobjid = tbl.oid
+      JOIN pg_class seq ON seq.oid = dep.objid AND seq.relkind = 'S'
+      JOIN pg_namespace seq_ns ON seq_ns.oid = seq.relnamespace
+      WHERE tbl.relkind IN ('r', 'p')
+        AND dep.deptype IN ('a', 'i')
+        AND (excluded.schema_name IS NULL OR tbl_ns.nspname = excluded.schema_name)
+    `;
+    const output = String(await this.runSql(query, ["-At"]));
+    return output.split("\n").map((line) => line.trim()).filter(Boolean);
+  }
+  getConnectionArgs(includeDatabase = true) {
+    const { username, host, port, database } = this.dbOpts;
+    return [
+      "-U",
+      username,
+      "-h",
+      host,
+      ...port ? ["-p", String(port)] : [],
+      ...includeDatabase ? ["-d", database] : []
+    ];
+  }
+  runSql(query, extraArgs = [], toolchain = this.backupToolchain) {
+    const { password } = this.dbOpts;
+    return runSpawn(
+      this.getSqlCommandName(toolchain),
+      [...this.getConnectionArgs(), ...extraArgs, "-c", query],
+      this.getPasswordEnvVars(password, toolchain)
+    );
+  }
+  runRestore(args, toolchain = this.backupToolchain) {
+    const { password } = this.dbOpts;
+    return runSpawn(this.getRestoreCommandName(toolchain), args, this.getPasswordEnvVars(password, toolchain));
+  }
+  async restore({
+    filePath,
+    schema,
+    skipDropAllTables = false,
+    restoreMode,
+    toolchain = this.backupToolchain
+  }) {
     let schemaOption = this.dbOpts.schema;
     if (schema && !schemaOption) {
       schemaOption = "public";
     }
+    if (schema) {
+      assertPostgresSchemaIdentifier(schema);
+    }
+    if (schemaOption) {
+      assertPostgresSchemaIdentifier(schemaOption);
+    }
     const cpuCores = import_os.default.cpus().length;
     const j = Math.max(1, Math.floor(cpuCores / 2));
     const schemaNameCondition = schemaOption ? `WHERE schemaname = '${schemaOption}'` : `WHERE schemaname NOT IN ('pg_catalog', 'information_schema')`;
     const relnamespaceCondition = schemaOption ? `WHERE relnamespace = '${schemaOption}'::regnamespace` : `WHERE tgrelid IN (SELECT oid FROM pg_class WHERE relnamespace NOT IN (SELECT oid FROM pg_catalog.pg_namespace WHERE nspname IN ('pg_catalog', 'information_schema')))`;
-    if (!skipDropAllTables) {
-      const dropDataCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
-    DO ${D$$} DECLARE r RECORD;
+    if (restoreMode === "preserveTables") {
+      const dropViewsQuery = `
+    DO $$ DECLARE r RECORD;
+    BEGIN
+    FOR r IN (
+      SELECT schemaname, viewname, false AS materialized FROM pg_views ${schemaNameCondition}
+      UNION ALL
+      SELECT schemaname, matviewname AS viewname, true AS materialized FROM pg_matviews ${schemaNameCondition}
+    ) LOOP
+      BEGIN
+        IF r.materialized THEN
+          EXECUTE 'DROP MATERIALIZED VIEW IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.viewname) || ' CASCADE';
+        ELSE
+          EXECUTE 'DROP VIEW IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.viewname) || ' CASCADE';
+        END IF;
+      EXCEPTION
+        WHEN OTHERS THEN
+      END;
+    END LOOP;
+    END $$;`;
+      await this.runSql(dropViewsQuery, [], toolchain);
+    } else if (!skipDropAllTables) {
+      const dropDataQuery = `
+    DO $$ DECLARE r RECORD;
     BEGIN
     FOR r IN (SELECT viewname,schemaname FROM pg_views ${schemaNameCondition}) LOOP
         BEGIN
-          EXECUTE 'DROP VIEW IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.tablename) || ' CASCADE';
+          EXECUTE 'DROP VIEW IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.viewname) || ' CASCADE';
         EXCEPTION
           WHEN OTHERS THEN
         END;
@@ -387,7 +594,7 @@ class PostgresAdapter extends BaseDBAdapter {
 
     FOR r IN (SELECT sequencename,schemaname FROM pg_sequences ${schemaNameCondition}) LOOP
       BEGIN
-        EXECUTE 'DROP SEQUENCE IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.tablename) || ' CASCADE';
+        EXECUTE 'DROP SEQUENCE IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.sequencename) || ' CASCADE';
       EXCEPTION
         WHEN OTHERS THEN
       END;
@@ -405,54 +612,95 @@ class PostgresAdapter extends BaseDBAdapter {
       END;
     END LOOP;
 
-    END ${D$$};"`.replace(/\n/g, " ");
-      await run(dropDataCommand, { PGPASSWORD: password });
+    END $$;`;
+      await this.runSql(dropDataQuery, [], toolchain);
     }
     if (schema === schemaOption || !schemaOption) {
-      const pgRestoreCommand = `${this.#restoreCmd} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} --clean --if-exists --no-owner -j ${j} ${filePath}`;
-      await run(pgRestoreCommand, { PGPASSWORD: password });
+      const restoreList = restoreMode === "preserveTables" ? await this.createRestoreListWithoutSchema(filePath, toolchain) : void 0;
+      const restoreArgs = [
+        ...this.getConnectionArgs(),
+        "--clean",
+        "--if-exists",
+        "--no-owner",
+        "-j",
+        String(j),
+        ...restoreList ? ["-L", restoreList.filePath] : [],
+        filePath
+      ];
+      try {
+        await this.runRestore(restoreArgs, toolchain);
+      } finally {
+        if (restoreList) {
+          await fsPromises.unlink(restoreList.filePath).catch(() => {
+          });
+        }
+      }
     } else {
       const srcSchema = schema || "public";
-      const pgRestoreCommand = `${this.#restoreCmd} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -n ${srcSchema} -d ${database} --clean --if-exists --no-owner -j ${j} ${filePath}`;
-      await this.#restoreSchema(srcSchema, schemaOption, pgRestoreCommand);
+      const pgRestoreArgs = this.buildSchemaRestoreArgs(srcSchema, schemaOption, filePath, j, toolchain);
+      await this.restoreSchema(srcSchema, schemaOption, pgRestoreArgs, toolchain);
     }
   }
-  async #restoreSchema(srcSchema, targetSchema, pgRestoreCommand) {
-    const { username, host, port, database, password } = this.dbOpts;
+  async createRestoreListWithoutSchema(filePath, toolchain = this.backupToolchain) {
+    const listOutput = String(await this.runRestore(["--list", filePath], toolchain));
+    const filteredList = listOutput.split("\n").filter((line) => !isPgRestoreSchemaTocEntry(line)).join("\n");
+    const listFilePath = import_path.default.join(
+      import_os.default.tmpdir(),
+      `nocobase-pg-restore-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.list`
+    );
+    await fsPromises.writeFile(listFilePath, filteredList);
+    return {
+      filePath: listFilePath
+    };
+  }
+  buildSchemaRestoreArgs(srcSchema, _targetSchema, filePath, jobs, _toolchain = this.backupToolchain) {
+    return [
+      ...this.getConnectionArgs(),
+      "-n",
+      srcSchema,
+      "--clean",
+      "--if-exists",
+      "--no-owner",
+      "-j",
+      String(jobs),
+      filePath
+    ];
+  }
+  async restoreSchema(srcSchema, targetSchema, pgRestoreArgs, toolchain = this.backupToolchain) {
     const ts = Date.now();
-    const preCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
-    DO ${D$$}
+    const preQuery = `
+    DO $$
     BEGIN
         IF EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = '${srcSchema}') THEN
             EXECUTE 'ALTER SCHEMA ${srcSchema} RENAME TO ${srcSchema}_${ts}';
         END IF;
         EXECUTE 'CREATE SCHEMA ${srcSchema}';
-    END ${D$$};"`.replace(/\n/g, " ");
-    const postCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
-    DO ${D$$}
+    END $$;`;
+    const postQuery = `
+    DO $$
     BEGIN
         EXECUTE 'DROP SCHEMA ${targetSchema} CASCADE';
         EXECUTE 'ALTER SCHEMA ${srcSchema} RENAME TO ${targetSchema}';
         IF EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = '${srcSchema}_${ts}') THEN
             EXECUTE 'ALTER SCHEMA ${srcSchema}_${ts} RENAME TO ${srcSchema}';
         END IF;
-    END ${D$$};"`.replace(/\n/g, " ");
-    await run(preCommand, { PGPASSWORD: password });
+    END $$;`;
+    await this.runSql(preQuery, [], toolchain);
     try {
-      await run(pgRestoreCommand, { PGPASSWORD: password });
+      await this.runRestore(pgRestoreArgs, toolchain);
     } finally {
-      await run(postCommand, { PGPASSWORD: password });
+      await this.runSql(postQuery, [], toolchain);
     }
-    await this.#syncCollectionSchemaMetadata(srcSchema, targetSchema);
+    await this.syncCollectionSchemaMetadata(srcSchema, targetSchema, toolchain);
   }
-  async #syncCollectionSchemaMetadata(srcSchema, targetSchema) {
-    const { username, host, port, database, password, tablePrefix } = this.dbOpts;
+  async syncCollectionSchemaMetadata(srcSchema, targetSchema, toolchain = this.backupToolchain) {
+    const { tablePrefix } = this.dbOpts;
     const collectionsTable = `${tablePrefix || ""}collections`;
     const targetSchemaLiteral = escapeStringLiteral(targetSchema);
     const srcSchemaLiteral = escapeStringLiteral(srcSchema);
     const collectionsTableLiteral = escapeStringLiteral(collectionsTable);
-    const updateCollectionSchemaCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
-    DO ${D$$}
+    const updateCollectionSchemaQuery = `
+    DO $$
     DECLARE
         collections_table text := '${collectionsTableLiteral}';
     BEGIN
@@ -470,8 +718,71 @@ class PostgresAdapter extends BaseDBAdapter {
               '${srcSchemaLiteral}'
             );
         END IF;
-    END ${D$$};"`.replace(/\n/g, " ");
-    await run(updateCollectionSchemaCommand, { PGPASSWORD: password });
+    END $$;`;
+    await this.runSql(updateCollectionSchemaQuery, [], toolchain);
+  }
+}
+class KingbaseAdapter extends PostgresAdapter {
+  get backupToolchain() {
+    return this.hasKingbaseToolchain() ? "kingbase" : "postgres";
+  }
+  getKingbaseBackupCommandName() {
+    return formatPathInEnv(process.env.KINGBASE_DUMP_PATH) || "sys_dump";
+  }
+  getKingbaseRestoreCommandName() {
+    return formatPathInEnv(process.env.KINGBASE_RESTORE_PATH) || "sys_restore";
+  }
+  getKingbaseSqlCommandName() {
+    return formatPathInEnv(process.env.KINGBASE_PSQL_PATH) || "ksql";
+  }
+  hasKingbaseToolchain() {
+    return this.hasCommand(this.getKingbaseBackupCommandName()) && this.hasCommand(this.getKingbaseRestoreCommandName()) && this.hasCommand(this.getKingbaseSqlCommandName());
+  }
+  getBackupCommandName(toolchain = this.backupToolchain) {
+    return toolchain === "kingbase" ? this.getKingbaseBackupCommandName() : super.getBackupCommandName(toolchain);
+  }
+  getRestoreCommandName(toolchain = this.backupToolchain) {
+    return toolchain === "kingbase" ? this.getKingbaseRestoreCommandName() : super.getRestoreCommandName(toolchain);
+  }
+  getSqlCommandName(toolchain = this.backupToolchain) {
+    return toolchain === "kingbase" ? this.getKingbaseSqlCommandName() : super.getSqlCommandName(toolchain);
+  }
+  getPasswordEnvVars(password, toolchain = this.backupToolchain) {
+    if (toolchain === "postgres") {
+      return super.getPasswordEnvVars(password, toolchain);
+    }
+    return { KINGBASE_PASSWORD: password };
+  }
+  getBackupSchema() {
+    return this.dbOpts.schema || "public";
+  }
+  buildSchemaRestoreArgs(srcSchema, targetSchema, filePath, jobs, toolchain = this.backupToolchain) {
+    if (toolchain === "postgres") {
+      return super.buildSchemaRestoreArgs(srcSchema, targetSchema, filePath, jobs, toolchain);
+    }
+    return [
+      ...this.getConnectionArgs(),
+      "-g",
+      srcSchema,
+      "-G",
+      targetSchema,
+      "--clean",
+      "--if-exists",
+      "--no-owner",
+      "-j",
+      String(jobs),
+      filePath
+    ];
+  }
+  async restoreSchema(srcSchema, targetSchema, restoreArgs, toolchain = this.backupToolchain) {
+    if (toolchain === "postgres") {
+      await super.restoreSchema(srcSchema, targetSchema, restoreArgs, toolchain);
+      return;
+    }
+    const targetSchemaIdentifier = quotePgIdentifier(targetSchema);
+    await this.runSql(`CREATE SCHEMA IF NOT EXISTS ${targetSchemaIdentifier};`, [], toolchain);
+    await this.runRestore(restoreArgs, toolchain);
+    await this.syncCollectionSchemaMetadata(srcSchema, targetSchema, toolchain);
   }
 }
 class SQLiteAdapter extends BaseDBAdapter {
@@ -492,6 +803,7 @@ class MariaDBAdapter extends MySQLAdapter {
 const adapterMap = {
   mysql: MySQLAdapter,
   postgres: PostgresAdapter,
+  kingbase: KingbaseAdapter,
   sqlite: SQLiteAdapter,
   mariadb: MariaDBAdapter
 };

package/dist/server/index.d.ts

@@ -9,5 +9,5 @@
 export { BackupManager } from './managers/backup';
 export type { BackupSettings, BackupCreator, BackupTaskResult } from './managers/backup';
 export { RestoreManager, RestoreOptions } from './managers/restore';
-export { BACKUP_EXTENSION } from './utils';
+export { BACKUP_EXTENSION, METADATA_EXTENSION, Extractor, compressDirectoryToBackupArchive } from './utils';
 export { default } from './plugin';

package/dist/server/index.js

@@ -38,8 +38,11 @@ var server_exports = {};
 __export(server_exports, {
   BACKUP_EXTENSION: () => import_utils.BACKUP_EXTENSION,
   BackupManager: () => import_backup.BackupManager,
+  Extractor: () => import_utils.Extractor,
+  METADATA_EXTENSION: () => import_utils.METADATA_EXTENSION,
   RestoreManager: () => import_restore.RestoreManager,
   RestoreOptions: () => import_restore.RestoreOptions,
+  compressDirectoryToBackupArchive: () => import_utils.compressDirectoryToBackupArchive,
   default: () => import_plugin.default
 });
 module.exports = __toCommonJS(server_exports);
@@ -51,6 +54,9 @@ var import_plugin = __toESM(require("./plugin"));
 0 && (module.exports = {
   BACKUP_EXTENSION,
   BackupManager,
+  Extractor,
+  METADATA_EXTENSION,
   RestoreManager,
-  RestoreOptions
+  RestoreOptions,
+  compressDirectoryToBackupArchive
 });

package/dist/server/managers/backup.d.ts

@@ -11,16 +11,20 @@ import { ResourcerContext } from '@nocobase/resourcer';
 import Application from '@nocobase/server';
 import { Readable } from 'stream';
 export interface BackupSettings {
-    storageId?: string;
+    storageId?: string | number | null;
     encryptionPassword: string;
     enableFilesBackup: boolean;
     keep?: number;
     scheduled: boolean;
     cron: string;
+    /**
+     * @deprecated Prefer excludeTables. includeTables may miss dependent database objects.
+     */
     includeTables?: string[];
     excludeTables?: string[];
     description?: string;
     createdBy?: BackupCreator;
+    metadata?: Record<string, unknown>;
 }
 export interface BackupFile {
     name: string;
@@ -38,11 +42,14 @@ export interface BackupTaskResult {
     message?: string;
     inProgress: boolean;
 }
+type BackupSettingsInput = BackupSettings & {
+    toJSON?: () => Partial<BackupSettings>;
+};
 export declare class BackupManager {
     #private;
     app: Application;
     ctx: ResourcerContext | null;
-    constructor(app: Application, ctx: ResourcerContext | null, settings: BackupSettings);
+    constructor(app: Application, ctx: ResourcerContext | null, settings: BackupSettingsInput);
     protected set backupPrefix(backupPrefix: string);
     protected set backupDir(backupDir: string);
     protected set tempDir(tempDir: string);
@@ -54,3 +61,4 @@ export declare class BackupManager {
     list(): Promise<BackupFile[]>;
     createReadStream(fileName: string): Promise<Readable>;
 }
+export {};