@nocobase/plugin-backups 2.0.56

package/dist/server/managers/restore.js

@@ -0,0 +1,434 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var restore_exports = {};
+__export(restore_exports, {
+  RestoreManager: () => RestoreManager
+});
+module.exports = __toCommonJS(restore_exports);
+var crypto = __toESM(require("crypto"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_utils = require("@nocobase/utils");
+var import_semver = __toESM(require("semver"));
+var import_util = require("util");
+var import_database = require("../adapters/database");
+var import_utils2 = require("../utils");
+const RESTORE_STEPS = {
+  BEGIN: "restoring begin",
+  DATABASE: "restoring database",
+  UPLOADS: "restoring uploaded files",
+  END: "restoring end"
+};
+class RestoreManager {
+  ctx;
+  #dbAdapter;
+  #backupDir;
+  #tempDir;
+  #uploadDir;
+  #aesKeyPath;
+  constructor(ctx, dbOptions) {
+    this.ctx = ctx;
+    this.#dbAdapter = (0, import_database.getDBAdapter)(dbOptions || ctx.app.db.options);
+    this.#backupDir = (0, import_utils.storagePathJoin)("backups", ctx.app.name);
+    this.#tempDir = (0, import_utils.storagePathJoin)("tmp", "backups", ctx.app.name);
+    this.#uploadDir = (0, import_utils.storagePathJoin)("uploads");
+    this.#aesKeyPath = (0, import_utils.storagePathJoin)("apps", ctx.app.name, "aes_key.dat");
+  }
+  async restoreFromBackup(backupFileName, taskId, password, tolerentMode, options) {
+    const backupFilePath = this.#getValidatedBackupFilePath(backupFileName);
+    await this.restore(backupFilePath, taskId, password, tolerentMode, void 0, options);
+  }
+  async restoreFromUpload(backupFile, taskId, password, tolerentMode, options) {
+    const backupFilePath = backupFile.path;
+    await this.restore(backupFilePath, taskId, password, tolerentMode, void 0, options);
+  }
+  async restoreCLI(filePath, password, tolerentMode, skipRevertOnError, options) {
+    await this.#dbAdapter.check("restore");
+    const extractedDir = await this.#decompressFiles(filePath, password);
+    const backupFiles = await import_promises.default.readdir(extractedDir);
+    const dbFile = backupFiles.find((file) => file === "data");
+    const metadataFile = backupFiles.find((file) => file === "_metadata.json");
+    const uploadsExist = backupFiles.includes("uploads");
+    if (!dbFile || !metadataFile) {
+      this.ctx.logger.error("Not a valid backup file", { module: import_utils2.BACKUPS });
+      throw new Error(this.#t("Not a valid backup file"));
+    }
+    const metadata = await this.#parseMetadataFile(import_path.default.join(extractedDir, metadataFile), tolerentMode, options);
+    try {
+      await this.#restoreDataCLI(extractedDir, dbFile, uploadsExist, metadata);
+    } catch (error) {
+      const dbVersion = await (0, import_utils2.getDBVersion)(this.ctx.app.db);
+      const restoreClientVersion = await this.#dbAdapter.clientVersion("restore");
+      this.ctx.logger.error(
+        `Error restoring backup: "${error.message}".
+        Database Version: backup[${metadata.database.version}], current[${dbVersion}],
+        Client Version: backup[${metadata.database.backupClientVersion}], restore[${restoreClientVersion}]
+        `,
+        { module: import_utils2.BACKUPS }
+      );
+      if (tolerentMode && error.message.includes("ignored")) {
+        this.ctx.logger.warn("Tolerent mode enabled, ignoring the error and continue the upgrade.", {
+          module: import_utils2.BACKUPS
+        });
+        await this.#restoreFilesAndCleanup(uploadsExist, extractedDir);
+        await this.ctx.app.upgrade();
+      } else if (!skipRevertOnError) {
+        await this.#revertDbRestore();
+      }
+    }
+  }
+  #getValidatedBackupFilePath(backupFileName) {
+    const filePath = (0, import_utils2.resolvePathWithinBase)(this.#backupDir, backupFileName);
+    if (import_path.default.basename(backupFileName) !== backupFileName || !backupFileName.endsWith(`.${import_utils2.BACKUP_EXTENSION}`) || !filePath || !import_fs_extra.default.existsSync(filePath)) {
+      throw new Error(this.#t("FILE_NOT_FOUND", backupFileName));
+    }
+    return filePath;
+  }
+  async #restoreDataCLI(extractedDir, dbFile, restoreUploads, metadata) {
+    const tmpBackupDir = import_path.default.join(this.#tempDir, "before-restore");
+    try {
+      await import_fs_extra.default.mkdir(tmpBackupDir, { recursive: true });
+      await this.ctx.app.emitAsync("beforeStop");
+      await this.ctx.app.emitAsync("afterStop");
+      await this.#dbAdapter.restore(import_path.default.join(extractedDir, dbFile), metadata.database.schema);
+      this.ctx.logger.info("Database restored successfully", { module: import_utils2.BACKUPS });
+      await this.#restoreFilesAndCleanup(restoreUploads, extractedDir);
+    } catch (error) {
+      this.ctx.logger.error(`Error restoring backup: ${error.message}. Trying to revert the backup process`, {
+        module: import_utils2.BACKUPS
+      });
+      throw error;
+    }
+  }
+  async getStatusCache() {
+    try {
+      return this.ctx.app.cacheManager.getCache(import_utils2.RESTORE_TASKS_CACHE_NAME);
+    } catch (e) {
+      return await this.ctx.app.cacheManager.createCache({
+        name: import_utils2.RESTORE_TASKS_CACHE_NAME,
+        store: "memory",
+        ttl: import_utils2.RESTORE_TASKS_CACHE_TTL,
+        max: 10
+      });
+    }
+  }
+  async restore(filePath, taskId, password, tolerentMode, skipRevertOnError, options) {
+    await this.#dbAdapter.check("restore");
+    const extractedDir = await this.#decompressFiles(filePath, password);
+    const backupFiles = await import_promises.default.readdir(extractedDir);
+    const dbFile = backupFiles.find((file) => file === "data");
+    const metadataFile = backupFiles.find((file) => file === "_metadata.json");
+    const uploadsExist = backupFiles.includes("uploads");
+    if (!dbFile || !metadataFile) {
+      this.ctx.logger.error("Not a valid backup file", { module: import_utils2.BACKUPS });
+      throw new Error(this.#t("Not a valid backup file"));
+    }
+    const metadata = await this.#parseMetadataFile(import_path.default.join(extractedDir, metadataFile), tolerentMode, options);
+    this.#restoreData(extractedDir, dbFile, uploadsExist, taskId, metadata).catch(async (error) => {
+      try {
+        const dbVersion = await (0, import_utils2.getDBVersion)(this.ctx.app.db);
+        const restoreClientVersion = await this.#dbAdapter.clientVersion("restore");
+        this.ctx.logger.error(
+          `Error restoring backup: "${error.message}".
+          Database Version: backup[${metadata.database.version}], current[${dbVersion}],
+          Client Version: backup[${metadata.database.backupClientVersion}], restore[${restoreClientVersion}]
+          `,
+          { module: import_utils2.BACKUPS }
+        );
+        if (tolerentMode && error.message.includes("ignored")) {
+          this.ctx.logger.warn("Tolerent mode enabled, ignoring the error and continue the upgrade.", {
+            module: import_utils2.BACKUPS
+          });
+          await this.#restoreFilesAndCleanup(uploadsExist, extractedDir);
+          await this.ctx.app.runCommand("upgrade");
+        } else {
+          if (!tolerentMode && this.#dbAdapter.dbOpts.dialect === "postgres") {
+            const backupClientVersion = Number((0, import_utils2.toMajorVersion)(metadata.database.backupClientVersion));
+            const dbServerVersion = Number((0, import_utils2.toMajorVersion)(dbVersion));
+            if (backupClientVersion > 16 && dbServerVersion <= 16) {
+              const statusCache = await this.getStatusCache();
+              await statusCache.set(taskId, {
+                message: this.#t("ERROR_PG_DUMP_LT_17")
+              });
+            }
+          }
+          if (!skipRevertOnError) {
+            await this.#revertDbRestore();
+          }
+          await this.ctx.app.runCommand("upgrade");
+        }
+      } catch (err) {
+        this.ctx.logger.error(`Error handling restore failure: ${err.message}`, { module: import_utils2.BACKUPS });
+      }
+    });
+  }
+  async #parseMetadataFile(filePath, tolerentMode, options) {
+    let metadata;
+    try {
+      const metadataContent = await import_promises.default.readFile(filePath, "utf-8");
+      metadata = JSON.parse(metadataContent);
+    } catch (error) {
+      this.ctx.logger.error(`Error parsing metadata file: ${error.message}`, { module: import_utils2.BACKUPS });
+      throw new Error(this.#t("ERROR_PARSING_BACKUP_FILE", error.message));
+    }
+    await this.#assertMetadata(metadata, tolerentMode, options);
+    return metadata;
+  }
+  async #assertMetadata(metadata, tolerentMode, options) {
+    var _a, _b, _c, _d, _e, _f;
+    const { version: backupVersion } = metadata;
+    const packageVersion = this.ctx.app.getPackageVersion();
+    const extractVersion = (version) => {
+      const match = version.match(/^(\d+\.\d+\.\d+)/);
+      return match ? match[0] : version;
+    };
+    if (import_semver.default.gt(extractVersion(backupVersion), extractVersion(packageVersion))) {
+      throw new Error(this.#t("BACKUP_VERSION_MISMATCH", { backupVersion, currentVersion: packageVersion }));
+    }
+    const { dialect, underscored, tablePrefix, schema } = this.#dbAdapter.dbOpts;
+    if (metadata.database.dialect !== dialect) {
+      throw new Error(this.#t("Database dialect mismatch"));
+    }
+    if ((metadata.database.underscored || false) != (underscored || false)) {
+      throw new Error(this.#t("Database underscored mismatch"));
+    }
+    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";
+    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"));
+      }
+      if (!((_f = (_e = this.ctx.request) == null ? void 0 : _e.body) == null ? void 0 : _f.dbSchema) && (schema || "") !== (metadata.database.schema || "")) {
+        throw new Error(this.#t("Database schema mismatch"));
+      }
+    }
+    const dbVersionInBackup = (0, import_utils2.toMajorVersion)(metadata.database.version);
+    if (!tolerentMode && dbVersionInBackup) {
+      const dbVersionRaw = await (0, import_utils2.getDBVersion)(this.ctx.app.db);
+      const dbVersion = (0, import_utils2.toMajorVersion)(dbVersionRaw);
+      if (dbVersionInBackup > dbVersion) {
+        throw new Error(
+          this.#t(
+            "Database version is lower than the backup, if you really want to restore, please enable the tolerent mode."
+          )
+        );
+      }
+    }
+    const pluginsInBackup = metadata.plugins;
+    const missingPlugins = pluginsInBackup.filter((plugin) => {
+      try {
+        require.resolve(plugin.packageName);
+        return false;
+      } catch (error) {
+        return true;
+      }
+    });
+    if (missingPlugins.length) {
+      const missingPluginsMsg = this.#t(
+        "WARN_RESTORING_BACKUP_MISSING_PLUGINS",
+        missingPlugins.map((plugin) => plugin.name).join(", ")
+      );
+      this.ctx.logger.warn(missingPluginsMsg, {
+        module: import_utils2.BACKUPS
+      });
+    }
+    return true;
+  }
+  async #decompressFiles(filePath, password) {
+    const fileBaseName = import_path.default.basename(filePath, `.${import_utils2.BACKUP_EXTENSION}`);
+    const outputDir = import_path.default.join(this.#tempDir, fileBaseName);
+    const inputFileStream = import_fs_extra.default.createReadStream(filePath);
+    let inputStream = null;
+    try {
+      await import_promises.default.mkdir(outputDir, { recursive: true });
+      inputStream = await this.#createDecryptedStream(inputFileStream, password);
+      const extractor = new import_utils2.Extractor({ path: outputDir });
+      const pipeline = (0, import_util.promisify)(require("stream").pipeline);
+      await pipeline(inputStream, extractor);
+      this.ctx.logger.info(`Backup file extracted to: ${outputDir}`, { module: import_utils2.BACKUPS });
+    } catch (error) {
+      this.ctx.logger.error(`Error decrypting file: ${error.message}. Please confirm your password.`, {
+        module: import_utils2.BACKUPS
+      });
+      throw new Error(this.#t("ERROR_DECRYPTING_PLS_CHECK_PASSWORD", error.message));
+    } finally {
+      if (!inputFileStream.closed) {
+        inputFileStream.close();
+      }
+      if (inputStream && inputStream !== inputFileStream && !inputStream.destroyed) {
+        inputStream.destroy();
+      }
+    }
+    return outputDir;
+  }
+  async #createDecryptedStream(input, password) {
+    if (!password) {
+      return input;
+    }
+    try {
+      const iv = await new Promise((resolve, reject) => {
+        let ivBuffer = Buffer.alloc(0);
+        const onReadable = () => {
+          let chunk;
+          while (null !== (chunk = input.read(16 - ivBuffer.length))) {
+            ivBuffer = Buffer.concat([ivBuffer, chunk]);
+            if (ivBuffer.length === 16) {
+              input.removeListener("readable", onReadable);
+              resolve(ivBuffer);
+              return;
+            }
+          }
+        };
+        input.once("error", (err) => {
+          input.removeListener("readable", onReadable);
+          reject(err);
+        });
+        input.once("end", () => {
+          input.removeListener("readable", onReadable);
+          if (ivBuffer.length < 16) {
+            reject(
+              new Error("Failed to read complete 16-byte IV from stream. File may be too short or not encrypted.")
+            );
+          }
+        });
+        input.on("readable", onReadable);
+      });
+      const key = await (0, import_util.promisify)(crypto.scrypt)(password, import_utils2.FILE_ENCRYPTION_SALT, 32);
+      const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
+      decipher.on("error", (err) => {
+        this.ctx.logger.error(`Decryption error: ${err.message}.`, { module: import_utils2.BACKUPS });
+      });
+      return input.pipe(decipher);
+    } catch (error) {
+      this.ctx.logger.error(`Error setting up decryption stream: ${error.message}`, { module: import_utils2.BACKUPS });
+      throw error;
+    }
+  }
+  async #restoreData(extractedDir, dbFile, restoreUploads, taskId, metadata) {
+    this.#notify(RESTORE_STEPS.BEGIN);
+    this.#notify(RESTORE_STEPS.DATABASE);
+    const statusCache = await this.getStatusCache();
+    const tmpBackupDir = import_path.default.join(this.#tempDir, "before-restore");
+    try {
+      await import_promises.default.mkdir(tmpBackupDir, { recursive: true });
+      await this.#dbAdapter.backup(tmpBackupDir);
+      await this.ctx.app.emitAsync("beforeStop");
+      await this.ctx.app.emitAsync("afterStop");
+      await this.#dbAdapter.restore(import_path.default.join(extractedDir, dbFile), metadata.database.schema);
+      this.ctx.logger.info("Database restored successfully", { module: import_utils2.BACKUPS });
+      if (restoreUploads) {
+        this.#notify(RESTORE_STEPS.UPLOADS);
+      }
+      await this.#restoreFilesAndCleanup(restoreUploads, extractedDir);
+    } catch (error) {
+      await statusCache.set(taskId, {
+        inProgress: false,
+        message: error.message
+      });
+      this.ctx.logger.error(`Error restoring backup: ${error.message}. Trying to revert the backup process`, {
+        module: import_utils2.BACKUPS
+      });
+      throw error;
+    } finally {
+      this.#notify(RESTORE_STEPS.END);
+    }
+    await statusCache.set(taskId, {
+      inProgress: false
+    });
+    await this.ctx.app.runCommand("upgrade");
+  }
+  async #restoreFilesAndCleanup(restoreUploads, extractedDir) {
+    if (restoreUploads) {
+      const uploadsDir = import_path.default.join(extractedDir, "uploads");
+      await import_promises.default.mkdir(this.#uploadDir, { recursive: true });
+      await import_fs_extra.default.copy(uploadsDir, this.#uploadDir, { overwrite: true });
+    }
+    const aesKeyPath = import_path.default.join(extractedDir, "aes_key.dat");
+    if (await import_fs_extra.default.pathExists(aesKeyPath)) {
+      await import_fs_extra.default.copy(aesKeyPath, this.#aesKeyPath, { overwrite: true });
+    }
+    import_fs_extra.default.rm(extractedDir, { recursive: true }).catch((e) => {
+      this.ctx.logger.error(`Error cleaning up the temp directory: ${e.message}`, { module: import_utils2.BACKUPS });
+    });
+  }
+  async #revertDbRestore() {
+    this.ctx.logger.info("Reverting the database restore process", { module: import_utils2.BACKUPS });
+    const dbFile = import_path.default.join(this.#tempDir, "before-restore", "data");
+    if (await import_fs_extra.default.pathExists(dbFile)) {
+      try {
+        await this.#dbAdapter.restore(dbFile, this.#dbAdapter.dbOpts.schema);
+      } catch (error) {
+        this.ctx.logger.error("Error reverting the database restore process", { module: import_utils2.BACKUPS });
+      }
+    } else {
+      this.ctx.logger.error("Database backup file for revert restore process not found", { module: import_utils2.BACKUPS });
+    }
+  }
+  async #notify(step) {
+    const app = await this.ctx.app;
+    if (step === RESTORE_STEPS.BEGIN) {
+      app.emit("maintaining", { status: "command_begin" });
+      return;
+    }
+    if (step === RESTORE_STEPS.END) {
+      app.emit("maintaining", { status: "command_end" });
+      return;
+    }
+    app.emit("maintainingMessageChanged", {
+      message: `${step}...`,
+      maintainingStatus: {
+        command: {
+          name: "APP restoring"
+        },
+        status: "command_running"
+      }
+    });
+  }
+  #t(message, detail) {
+    if (typeof detail === "object") {
+      return this.ctx.i18n.t(message, { ...detail, ns: import_utils2.PLUGIN_BACKUPS_NAME, interpolation: { escapeValue: false } });
+    }
+    return this.ctx.i18n.t(message, { detail, ns: import_utils2.PLUGIN_BACKUPS_NAME, interpolation: { escapeValue: false } });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RestoreManager
+});

package/dist/server/plugin.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { InstallOptions, Plugin } from '@nocobase/server';
+export declare class PluginBackupsServer extends Plugin {
+    #private;
+    afterAdd(): Promise<void>;
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+    install(options?: InstallOptions): Promise<void>;
+    private runAutoBackupTask;
+    afterEnable(): Promise<void>;
+    afterDisable(): Promise<void>;
+    remove(): Promise<void>;
+    backup(): Promise<string>;
+    restore(backupFilePath: string, options?: {
+        skipRevertOnError?: boolean;
+    }): Promise<void>;
+    static staticImport(): Promise<void>;
+}
+export default PluginBackupsServer;