@nocobase/plugin-backups 2.2.0-alpha.1 → 2.2.0-alpha.2

package/dist/server/adapters/database.js

@@ -52,8 +52,15 @@ 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}`);
   }
@@ -68,6 +75,20 @@ 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 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 +96,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;
@@ -88,10 +114,18 @@ class BaseDBAdapter {
       (0, import_child_process.execSync)(`${command} --version`);
     } catch (error) {
       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) {
+    try {
+      (0, import_child_process.execSync)(`${command} --version`);
+      return true;
+    } catch (_error) {
+      return false;
+    }
+  }
 }
 class MySQLAdapter extends BaseDBAdapter {
   #backupCmd = "mysqldump";
@@ -140,6 +174,7 @@ class MySQLAdapter extends BaseDBAdapter {
       "--set-gtid-purged=OFF",
       "--routines",
       "--triggers",
+      "--events",
       ...version && version > 7 ? ["--column-statistics=0"] : [],
       database
     ];
@@ -232,9 +267,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,24 +395,36 @@ 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();
     } catch (_error) {
@@ -347,31 +432,96 @@ class PostgresAdapter extends BaseDBAdapter {
     }
   }
   async backup({ dir, includeTables, excludeTables }) {
-    const { username, host, port, database, password, schema: backupSchema } = this.dbOpts;
+    const { username, host, port, database, password } = this.dbOpts;
     const filePath = `${dir}/data`;
+    const backupSchema = this.getBackupSchema();
     const schemaOption = backupSchema ? `--schema=${backupSchema}` : "";
+    const expandedExcludeTables = Array.isArray(excludeTables) ? [.../* @__PURE__ */ new Set([...excludeTables, ...await this.getOwnedSequenceTables(excludeTables, 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 excludeOption = expandedExcludeTables.length ? expandedExcludeTables.map((table) => `-T ${quotePgTablePattern(qualifyPgTablePattern(table, backupSchema))}`).join(" ") : "";
+    const command = `${this.getBackupCommandName()} ${includeOption} ${excludeOption} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -F c -b --quote-all-identifiers ${schemaOption} -f ${filePath} ${database}`;
+    await run(command, this.getPasswordEnvVars(password));
   }
-  async restore({ filePath, schema, skipDropAllTables = false }) {
+  async getOwnedSequenceTables(excludeTables, backupSchema) {
+    if (!Array.isArray(excludeTables) || !excludeTables.length) {
+      return [];
+    }
+    const { username, host, port, database, password } = this.dbOpts;
+    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 command = `${this.getSqlCommandName()} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -At -c ${quoteShellArg(query)}`;
+    const output = String(await run(command, this.getPasswordEnvVars(password)));
+    return output.split("\n").map((line) => line.trim()).filter(Boolean);
+  }
+  async restore({
+    filePath,
+    schema,
+    skipDropAllTables = false,
+    restoreMode,
+    toolchain = this.backupToolchain
+  }) {
     const { username, host, port, database, password } = this.dbOpts;
     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 "
+    if (restoreMode === "preserveTables") {
+      const dropViewsCommand = `${this.getSqlCommandName(toolchain)} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
+    DO ${D$$} 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 ${D$$};"`.replace(/\n/g, " ");
+      await run(dropViewsCommand, this.getPasswordEnvVars(password, toolchain));
+    } else if (!skipDropAllTables) {
+      const dropDataCommand = `${this.getSqlCommandName(toolchain)} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
     DO ${D$$} 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 +537,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;
@@ -406,21 +556,47 @@ class PostgresAdapter extends BaseDBAdapter {
     END LOOP;
 
     END ${D$$};"`.replace(/\n/g, " ");
-      await run(dropDataCommand, { PGPASSWORD: password });
+      await run(dropDataCommand, this.getPasswordEnvVars(password, 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 pgRestoreCommand = `${this.getRestoreCommandName(toolchain)} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} --clean --if-exists --no-owner -j ${j} ${(restoreList == null ? void 0 : restoreList.option) ?? ""} ${filePath}`;
+      try {
+        await run(pgRestoreCommand, this.getPasswordEnvVars(password, 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 pgRestoreCommand = this.buildSchemaRestoreCommand(srcSchema, schemaOption, filePath, j, toolchain);
+      await this.restoreSchema(srcSchema, schemaOption, pgRestoreCommand, toolchain);
     }
   }
-  async #restoreSchema(srcSchema, targetSchema, pgRestoreCommand) {
+  async createRestoreListWithoutSchema(filePath, toolchain = this.backupToolchain) {
+    const listOutput = String(await run(`${this.getRestoreCommandName(toolchain)} --list ${quoteShellArg(filePath)}`));
+    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 {
+      option: `-L ${quoteShellArg(listFilePath)}`,
+      filePath: listFilePath
+    };
+  }
+  buildSchemaRestoreCommand(srcSchema, _targetSchema, filePath, jobs, toolchain = this.backupToolchain) {
+    const { username, host, port, database } = this.dbOpts;
+    return `${this.getRestoreCommandName(toolchain)} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -n ${srcSchema} -d ${database} --clean --if-exists --no-owner -j ${jobs} ${filePath}`;
+  }
+  async restoreSchema(srcSchema, targetSchema, pgRestoreCommand, toolchain = this.backupToolchain) {
     const { username, host, port, database, password } = this.dbOpts;
     const ts = Date.now();
-    const preCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
+    const sqlCommandName = this.getSqlCommandName(toolchain);
+    const preCommand = `${sqlCommandName} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
     DO ${D$$}
     BEGIN
         IF EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = '${srcSchema}') THEN
@@ -428,7 +604,7 @@ class PostgresAdapter extends BaseDBAdapter {
         END IF;
         EXECUTE 'CREATE SCHEMA ${srcSchema}';
     END ${D$$};"`.replace(/\n/g, " ");
-    const postCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
+    const postCommand = `${sqlCommandName} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
     DO ${D$$}
     BEGIN
         EXECUTE 'DROP SCHEMA ${targetSchema} CASCADE';
@@ -437,21 +613,21 @@ class PostgresAdapter extends BaseDBAdapter {
             EXECUTE 'ALTER SCHEMA ${srcSchema}_${ts} RENAME TO ${srcSchema}';
         END IF;
     END ${D$$};"`.replace(/\n/g, " ");
-    await run(preCommand, { PGPASSWORD: password });
+    await run(preCommand, this.getPasswordEnvVars(password, toolchain));
     try {
-      await run(pgRestoreCommand, { PGPASSWORD: password });
+      await run(pgRestoreCommand, this.getPasswordEnvVars(password, toolchain));
     } finally {
-      await run(postCommand, { PGPASSWORD: password });
+      await run(postCommand, this.getPasswordEnvVars(password, toolchain));
     }
-    await this.#syncCollectionSchemaMetadata(srcSchema, targetSchema);
+    await this.syncCollectionSchemaMetadata(srcSchema, targetSchema, toolchain);
   }
-  async #syncCollectionSchemaMetadata(srcSchema, targetSchema) {
+  async syncCollectionSchemaMetadata(srcSchema, targetSchema, toolchain = this.backupToolchain) {
     const { username, host, port, database, password, 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 "
+    const updateCollectionSchemaCommand = `${this.getSqlCommandName(toolchain)} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
     DO ${D$$}
     DECLARE
         collections_table text := '${collectionsTableLiteral}';
@@ -471,7 +647,61 @@ class PostgresAdapter extends BaseDBAdapter {
             );
         END IF;
     END ${D$$};"`.replace(/\n/g, " ");
-    await run(updateCollectionSchemaCommand, { PGPASSWORD: password });
+    await run(updateCollectionSchemaCommand, this.getPasswordEnvVars(password, 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";
+  }
+  buildSchemaRestoreCommand(srcSchema, targetSchema, filePath, jobs, toolchain = this.backupToolchain) {
+    if (toolchain === "postgres") {
+      return super.buildSchemaRestoreCommand(srcSchema, targetSchema, filePath, jobs, toolchain);
+    }
+    const { username, host, port, database } = this.dbOpts;
+    return `${this.getRestoreCommandName(toolchain)} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -g ${srcSchema} -G ${targetSchema} -d ${database} --clean --if-exists --no-owner -j ${jobs} ${filePath}`;
+  }
+  async restoreSchema(srcSchema, targetSchema, restoreCommand, toolchain = this.backupToolchain) {
+    if (toolchain === "postgres") {
+      await super.restoreSchema(srcSchema, targetSchema, restoreCommand, toolchain);
+      return;
+    }
+    const { username, host, port, database, password } = this.dbOpts;
+    const targetSchemaIdentifier = quotePgIdentifier(targetSchema).replace(/"/g, '\\"');
+    const createSchemaCommand = `${this.getSqlCommandName(toolchain)} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "CREATE SCHEMA IF NOT EXISTS ${targetSchemaIdentifier};"`;
+    await run(createSchemaCommand, this.getPasswordEnvVars(password, toolchain));
+    await run(restoreCommand, this.getPasswordEnvVars(password, toolchain));
+    await this.syncCollectionSchemaMetadata(srcSchema, targetSchema, toolchain);
   }
 }
 class SQLiteAdapter extends BaseDBAdapter {
@@ -492,6 +722,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

@@ -17,10 +17,14 @@ export interface BackupSettings {
     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;

package/dist/server/managers/backup.js

@@ -50,7 +50,7 @@ var import_utils = require("@nocobase/utils");
 var import_util = require("util");
 var import_database = require("../adapters/database");
 var import_utils2 = require("../utils");
-const BACKUP_METADATA_VERSION = 1;
+const BACKUP_METADATA_VERSION = 2;
 class BackupManager {
   app;
   ctx;
@@ -99,7 +99,10 @@ class BackupManager {
   }
   async backup(fileBaseName, opts) {
     const contentPath = import_path.default.join(this.#tempDir, fileBaseName);
-    return this.#runBackupTask({ ...this.#settings, ...opts ?? {} }, fileBaseName, contentPath);
+    const runtimeTables = [...this.app.db.collections.values()].filter((collection) => collection.dataCategory === "runtime").map((collection) => collection.getTableNameWithSchemaAsString());
+    const backupOptions = { ...this.#settings, ...opts ?? {} };
+    backupOptions.excludeTables = [.../* @__PURE__ */ new Set([...backupOptions.excludeTables ?? [], ...runtimeTables])];
+    return this.#runBackupTask(backupOptions, fileBaseName, contentPath);
   }
   async destroy(fileName) {
     const filePath = this.#getValidatedFilePath(fileName);
@@ -187,6 +190,7 @@ class BackupManager {
       };
     });
     const metadata = {
+      ...opts.metadata ?? {},
       metadataVersion: BACKUP_METADATA_VERSION,
       enableFilesBackup: opts.enableFilesBackup,
       version: await this.app.version.get(),
@@ -194,6 +198,7 @@ class BackupManager {
       createdBy: opts.createdBy,
       database: {
         dialect,
+        toolchain: this.#dbAdapter.backupToolchain,
         underscored,
         tablePrefix,
         schema,

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

@@ -11,6 +11,7 @@ import { ResourcerContext } from '@nocobase/resourcer';
 export interface RestoreOptions {
     forceSchemaRestore?: boolean;
     skipDropAllTables?: boolean;
+    restoreMode?: 'preserveTables';
 }
 export declare class RestoreManager {
     #private;

package/dist/server/managers/restore.js

@@ -142,7 +142,9 @@ class RestoreManager {
       await this.#dbAdapter.restore({
         filePath: import_path.default.join(extractedDir, dbFile),
         schema: metadata.database.schema,
-        skipDropAllTables: (options == null ? void 0 : options.skipDropAllTables) === true
+        skipDropAllTables: (options == null ? void 0 : options.skipDropAllTables) === true,
+        restoreMode: options == null ? void 0 : options.restoreMode,
+        toolchain: this.#resolveRestoreToolchain(metadata)
       });
       this.ctx.logger.info("Database restored successfully", { module: import_utils2.BACKUPS });
       await this.#restoreFilesAndCleanup(restoreUploads, extractedDir);
@@ -195,7 +197,7 @@ class RestoreManager {
           await this.#restoreFilesAndCleanup(uploadsExist, extractedDir);
           await this.ctx.app.runCommand("upgrade");
         } else {
-          if (!tolerentMode && this.#dbAdapter.dbOpts.dialect === "postgres") {
+          if (!tolerentMode && this.#isPostgresLikeDialect(this.#dbAdapter.dbOpts.dialect)) {
             const backupClientVersion = Number((0, import_utils2.toMajorVersion)(metadata.database.backupClientVersion));
             const dbServerVersion = Number((0, import_utils2.toMajorVersion)(dbVersion));
             if (backupClientVersion > 16 && dbServerVersion <= 16) {
@@ -248,7 +250,7 @@ class RestoreManager {
     if ((metadata.database.tablePrefix || "") !== (tablePrefix || "")) {
       throw new Error(this.#t("Database table prefix mismatch"));
     }
-    const forceSchemaRestore = (options == null ? void 0 : options.forceSchemaRestore) === true && dialect === "postgres";
+    const forceSchemaRestore = (options == null ? void 0 : options.forceSchemaRestore) === true && this.#isPostgresLikeDialect(dialect);
     if (!forceSchemaRestore) {
       if (((_b = (_a = this.ctx.request) == null ? void 0 : _a.body) == null ? void 0 : _b.dbSchema) && ((_d = (_c = this.ctx.request) == null ? void 0 : _c.body) == null ? void 0 : _d.dbSchema) !== (schema || "public")) {
         throw new Error(this.#t("Database schema mismatch"));
@@ -289,6 +291,25 @@ class RestoreManager {
     }
     return true;
   }
+  #isPostgresLikeDialect(dialect) {
+    return dialect === "postgres" || dialect === "kingbase";
+  }
+  #resolveRestoreToolchain(metadata) {
+    if (metadata.database.dialect !== "kingbase") {
+      return void 0;
+    }
+    if (metadata.database.toolchain === "kingbase" || metadata.database.toolchain === "postgres") {
+      return metadata.database.toolchain;
+    }
+    const backupClientVersion = metadata.database.backupClientVersion || "";
+    if (/sys_dump/i.test(backupClientVersion)) {
+      return "kingbase";
+    }
+    if (/pg_dump|postgresql/i.test(backupClientVersion)) {
+      return "postgres";
+    }
+    return this.#dbAdapter.backupToolchain;
+  }
   async #decompressFiles(filePath, password) {
     const fileBaseName = import_path.default.basename(filePath, `.${import_utils2.BACKUP_EXTENSION}`);
     const outputDir = import_path.default.join(this.#tempDir, fileBaseName);
@@ -372,7 +393,9 @@ class RestoreManager {
       await this.#dbAdapter.restore({
         filePath: import_path.default.join(extractedDir, dbFile),
         schema: metadata.database.schema,
-        skipDropAllTables: (options == null ? void 0 : options.skipDropAllTables) === true
+        skipDropAllTables: (options == null ? void 0 : options.skipDropAllTables) === true,
+        restoreMode: options == null ? void 0 : options.restoreMode,
+        toolchain: this.#resolveRestoreToolchain(metadata)
       });
       this.ctx.logger.info("Database restored successfully", { module: import_utils2.BACKUPS });
       if (restoreUploads) {

package/dist/server/utils.d.ts

@@ -33,6 +33,7 @@ export declare class Extractor extends Writable {
     private extract;
     promise(): Promise<void>;
 }
+export declare function compressDirectoryToBackupArchive(sourceDir: string, backupFilePath: string): Promise<void>;
 export declare function humanFileSize(bytes: number, si?: boolean, dp?: number): string;
 export declare function getDBVersion(db: Database): Promise<string>;
 export declare function isQsTruly(value?: string | boolean): any;