@nocobase/plugin-backups 2.0.56

package/dist/server/plugin.js

@@ -0,0 +1,251 @@
+/**
+ * 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 plugin_exports = {};
+__export(plugin_exports, {
+  PluginBackupsServer: () => PluginBackupsServer,
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_lock_manager = require("@nocobase/lock-manager");
+var import_server = require("@nocobase/server");
+var import_cron_parser = __toESM(require("cron-parser"));
+var import_lodash = __toESM(require("lodash"));
+var import_path = __toESM(require("path"));
+var import_backup = require("./managers/backup");
+var import_restore = require("./managers/restore");
+var import_backup_cli = __toESM(require("./resourcers/backup-cli"));
+var import_backups = __toESM(require("./resourcers/backups"));
+var import_utils = require("./utils");
+const MAX_TIMEOUT_VALUE = 2147483647;
+const DEFAULT_SETTINGS = {
+  values: {
+    scheduled: false,
+    cron: "0 0 * * *",
+    keep: 100,
+    enableFilesBackup: true,
+    storageId: null,
+    encryptionPassword: ""
+  }
+};
+class PluginBackupsServer extends import_server.Plugin {
+  #autoBackupTimer = null;
+  async afterAdd() {
+  }
+  async beforeLoad() {
+    this.db.on(`${import_utils.SETTINGS}.afterUpdate`, async (model) => {
+      this.#autoBackupTimer = await this.#createBackupTimer(model);
+    });
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.settings`,
+      actions: [`${import_utils.SETTINGS}:get`, `${import_utils.SETTINGS}:update`]
+    });
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}`,
+      actions: ["backups:*", "backup:*"]
+    });
+  }
+  async load() {
+    await this.app.cacheManager.createCache({
+      name: import_utils.BACKUP_TASKS_CACHE_NAME,
+      store: "memory",
+      ttl: 24 * 60 * 60 * 1e3
+    });
+    await this.app.cacheManager.createCache({
+      name: import_utils.RESTORE_TASKS_CACHE_NAME,
+      store: "memory",
+      ttl: import_utils.RESTORE_TASKS_CACHE_TTL,
+      max: 10
+    });
+    this.app.acl.addFixedParams(import_utils.SETTINGS, "destroy", () => {
+      return {
+        "id.$ne": 1
+      };
+    });
+    this.app.resourceManager.define(import_backups.default);
+    this.app.resourceManager.define(import_backup_cli.default);
+    this.app.on("beforeStart", async () => {
+      await this.#makeSureSettingsExist();
+      this.#autoBackupTimer = await this.#createBackupTimer();
+    });
+    this.app.on("beforeStop", () => {
+      this.#cancelBackupTimer();
+    });
+  }
+  async install(options) {
+    await this.#makeSureSettingsExist();
+  }
+  async #makeSureSettingsExist() {
+    const hasSettings = await this.db.getRepository(import_utils.SETTINGS).findOne();
+    if (!hasSettings) {
+      await this.db.getRepository(import_utils.SETTINGS).create(DEFAULT_SETTINGS);
+    }
+  }
+  // Use TypeScript-level `private` (not `#`) so tests can call it via
+  // `(plugin as any).runAutoBackupTask()`.
+  async runAutoBackupTask() {
+    let release;
+    try {
+      const lock = await this.app.lockManager.tryAcquire(`backup:auto-task:${this.app.name}`);
+      release = await lock.acquire(60 * 60 * 1e3);
+    } catch (e) {
+      if (e instanceof import_lock_manager.LockAcquireError) {
+        this.log.info("Auto backup skipped: already running on another instance");
+        return;
+      }
+      throw e;
+    }
+    const settings = await this.db.getRepository(import_utils.SETTINGS).findOne();
+    const backupManager = new import_backup.BackupManager(this.app, null, settings);
+    let statusCache;
+    try {
+      statusCache = this.app.cacheManager.getCache(import_utils.BACKUP_TASKS_CACHE_NAME);
+    } catch {
+      statusCache = await this.app.cacheManager.createCache({
+        name: import_utils.BACKUP_TASKS_CACHE_NAME,
+        store: "memory",
+        ttl: 24 * 60 * 60 * 1e3
+      });
+    }
+    const backupName = await backupManager.createBackupName();
+    const fileName = `${backupName}.${import_utils.BACKUP_EXTENSION}`;
+    try {
+      await statusCache.set(fileName, {
+        inProgress: true
+      });
+      await backupManager.backup(backupName);
+    } catch (e) {
+      this.log.error(e);
+    } finally {
+      await statusCache.set(fileName, {
+        inProgress: false
+      });
+      await (release == null ? void 0 : release());
+    }
+  }
+  async #createBackupTimer(model) {
+    this.#cancelBackupTimer();
+    const backupSettings = model || await this.db.getRepository(import_utils.SETTINGS).findOne();
+    if (backupSettings.scheduled && backupSettings.cron) {
+      const interval = import_cron_parser.default.parseExpression(backupSettings.cron, { currentDate: /* @__PURE__ */ new Date() });
+      const next = interval.next();
+      const nextTime = next.getTime();
+      const timeout = nextTime - Date.now();
+      if (timeout < 0) {
+        return;
+      }
+      if (timeout > MAX_TIMEOUT_VALUE) {
+        return setTimeout(async () => {
+          this.#autoBackupTimer = await this.#createBackupTimer();
+        }, MAX_TIMEOUT_VALUE);
+      }
+      this.log.info(`Next backup scheduled at ${next}`);
+      return setTimeout(async () => {
+        await this.runAutoBackupTask();
+        this.#autoBackupTimer = await this.#createBackupTimer();
+      }, timeout);
+    }
+    return null;
+  }
+  #cancelBackupTimer() {
+    if (this.#autoBackupTimer) {
+      clearTimeout(this.#autoBackupTimer);
+      this.#autoBackupTimer = null;
+    }
+  }
+  async afterEnable() {
+  }
+  async afterDisable() {
+  }
+  async remove() {
+  }
+  async backup() {
+    const backupManager = new import_backup.BackupManager(this.app, null, {
+      scheduled: false,
+      cron: null,
+      encryptionPassword: null,
+      enableFilesBackup: false,
+      keep: 0
+    });
+    const fileBaseName = await backupManager.createBackupName();
+    const backupFilePath = await backupManager.backup(fileBaseName);
+    return backupFilePath;
+  }
+  async restore(backupFilePath, options) {
+    const ctx = {
+      app: this.app,
+      i18n: this.app.i18n,
+      logger: this.app.logger
+    };
+    const restoreManager = new import_restore.RestoreManager(ctx, this.app.db.options);
+    await restoreManager.restoreCLI(backupFilePath, null, true);
+  }
+  static async staticImport() {
+    import_server.Application.addCommand((app) => {
+      app.command("restore").argument("<filepath>").option("--underscored").option("--database [database]").option("--schema [schema]").action(async (filepath, opts) => {
+        const ctx = {
+          app,
+          i18n: app.i18n,
+          logger: app.logger
+        };
+        const dbOptions = {
+          ...app.db.options
+        };
+        if (opts.underscored) {
+          dbOptions.underscored = true;
+        }
+        if (opts.database) {
+          dbOptions.database = opts.database;
+        }
+        if (opts.schema) {
+          import_lodash.default.set(ctx, "request.body.dbSchema", opts.schema);
+          dbOptions["schema"] = opts.schema;
+          await app.db.sequelize.query(`CREATE SCHEMA IF NOT EXISTS "${opts.schema}"`);
+        }
+        const restoreManager = new import_restore.RestoreManager(ctx, dbOptions);
+        const backupFilePath = import_path.default.isAbsolute(filepath) ? filepath : import_path.default.resolve(process.cwd(), filepath);
+        const password = null;
+        const tolerentMode = true;
+        await restoreManager.restoreCLI(backupFilePath, password, tolerentMode);
+      });
+    });
+  }
+}
+var plugin_default = PluginBackupsServer;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginBackupsServer
+});

package/dist/server/resourcers/backup-cli.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ */
+declare const _default: {
+    name: string;
+    middleware: (ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>) => Promise<any>;
+    actions: {
+        list(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        create(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        status(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        download(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        remove(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        restore(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        restoreUpload(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        restoreStatus(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/resourcers/backup-cli.js

@@ -0,0 +1,237 @@
+/**
+ * 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 backup_cli_exports = {};
+__export(backup_cli_exports, {
+  default: () => backup_cli_default
+});
+module.exports = __toCommonJS(backup_cli_exports);
+var import_utils = require("@nocobase/utils");
+var import_crypto = __toESM(require("crypto"));
+var import_promises = __toESM(require("fs/promises"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_backup = require("../managers/backup");
+var import_restore = require("../managers/restore");
+var import_utils2 = require("../utils");
+async function setRestoreTaskError(statusCache, taskId, error) {
+  await statusCache.set(taskId, {
+    inProgress: false,
+    message: error instanceof Error ? error.message : String(error)
+  });
+}
+function getBackupName(ctx) {
+  var _a;
+  return ctx.action.params.name || ((_a = ctx.request.body) == null ? void 0 : _a.name);
+}
+function getPassword(ctx) {
+  var _a;
+  return ctx.action.params.password || ((_a = ctx.request.body) == null ? void 0 : _a.password);
+}
+function getSkipRevertOnError(ctx) {
+  var _a;
+  return (0, import_utils2.isQsTruly)(ctx.action.params.skipRevertOnError || ((_a = ctx.request.body) == null ? void 0 : _a.skipRevertOnError));
+}
+function getForceSchemaRestore(ctx) {
+  var _a;
+  return (0, import_utils2.isQsTruly)(ctx.action.params.force || ((_a = ctx.request.body) == null ? void 0 : _a.force));
+}
+function getBackupDir(ctx) {
+  return (0, import_utils.storagePathJoin)("backups", ctx.app.name);
+}
+function getBackupFilePath(ctx, name) {
+  const backupDir = getBackupDir(ctx);
+  const filePath = import_path.default.resolve(backupDir, name);
+  if (import_path.default.basename(name) !== name || !name.endsWith(`.${import_utils2.BACKUP_EXTENSION}`) || !filePath.startsWith(backupDir + import_path.default.sep)) {
+    ctx.throw(400, "Invalid backup name");
+  }
+  return filePath;
+}
+var backup_cli_default = {
+  name: "backup",
+  middleware: async (ctx, next) => {
+    if (ctx.action.actionName !== "restoreUpload") {
+      return next();
+    }
+    const storage = import_utils.koaMulter.diskStorage({
+      destination: import_os.default.tmpdir(),
+      filename: function(req, file, cb) {
+        const randomName = Date.now().toString() + Math.random().toString().slice(2);
+        cb(null, randomName);
+      }
+    });
+    const upload = (0, import_utils.koaMulter)({ storage }).single("file");
+    return upload(ctx, next);
+  },
+  actions: {
+    async list(ctx, next) {
+      const backupSettings = await ctx.db.getRepository(import_utils2.SETTINGS).findOne();
+      const backupManager = new import_backup.BackupManager(ctx.app, ctx, backupSettings);
+      ctx.body = await backupManager.list();
+      await next();
+    },
+    async create(ctx, next) {
+      const backupSettings = await ctx.db.getRepository(import_utils2.SETTINGS).findOne();
+      const backupManager = new import_backup.BackupManager(ctx.app, ctx, backupSettings);
+      const statusCache = ctx.app.cacheManager.getCache(import_utils2.BACKUP_TASKS_CACHE_NAME);
+      const backupName = await backupManager.createBackupName();
+      const fileName = `${backupName}.${import_utils2.BACKUP_EXTENSION}`;
+      backupManager.backup(backupName).then(async () => {
+        await statusCache.set(fileName, {
+          inProgress: false
+        });
+      }).catch(async (e) => {
+        await statusCache.set(fileName, {
+          inProgress: false,
+          message: e.message
+        });
+      });
+      await statusCache.set(fileName, {
+        inProgress: true
+      });
+      ctx.body = {
+        name: fileName,
+        inProgress: true
+      };
+      await next();
+    },
+    async status(ctx, next) {
+      const name = getBackupName(ctx);
+      if (!name) {
+        ctx.throw(400, "Backup name is required");
+        return;
+      }
+      const statusCache = ctx.app.cacheManager.getCache(import_utils2.BACKUP_TASKS_CACHE_NAME);
+      const results = await statusCache.mget(name);
+      ctx.body = {
+        [name]: results[0]
+      };
+      await next();
+    },
+    async download(ctx, next) {
+      const name = getBackupName(ctx);
+      if (!name) {
+        ctx.throw(400, "Backup name is required");
+        return;
+      }
+      const backupSettings = await ctx.db.getRepository(import_utils2.SETTINGS).findOne();
+      const backupManager = new import_backup.BackupManager(ctx.app, ctx, backupSettings);
+      ctx.attachment(name);
+      ctx.body = await backupManager.createReadStream(name);
+      await next();
+    },
+    async remove(ctx, next) {
+      const name = getBackupName(ctx);
+      if (!name) {
+        ctx.throw(400, "Backup name is required");
+        return;
+      }
+      const backupSettings = await ctx.db.getRepository(import_utils2.SETTINGS).findOne();
+      const backupManager = new import_backup.BackupManager(ctx.app, ctx, backupSettings);
+      await backupManager.destroy(name);
+      ctx.body = {
+        status: "ok"
+      };
+      await next();
+    },
+    async restore(ctx, next) {
+      const name = getBackupName(ctx);
+      if (!name) {
+        ctx.throw(400, "Backup name is required");
+        return;
+      }
+      const restoreManager = new import_restore.RestoreManager(ctx);
+      const taskId = import_crypto.default.randomUUID();
+      const statusCache = ctx.app.cacheManager.getCache(import_utils2.RESTORE_TASKS_CACHE_NAME);
+      await statusCache.set(taskId, {
+        inProgress: true
+      });
+      try {
+        await restoreManager.restore(
+          getBackupFilePath(ctx, name),
+          taskId,
+          getPassword(ctx),
+          true,
+          getSkipRevertOnError(ctx),
+          {
+            forceSchemaRestore: getForceSchemaRestore(ctx)
+          }
+        );
+        ctx.body = {
+          status: "ok",
+          task: taskId
+        };
+        await next();
+      } catch (error) {
+        await setRestoreTaskError(statusCache, taskId, error);
+        throw error;
+      }
+    },
+    async restoreUpload(ctx, next) {
+      var _a;
+      const restoreManager = new import_restore.RestoreManager(ctx);
+      const taskId = import_crypto.default.randomUUID();
+      const statusCache = ctx.app.cacheManager.getCache(import_utils2.RESTORE_TASKS_CACHE_NAME);
+      const uploadedFilePath = (_a = ctx.request.file) == null ? void 0 : _a.path;
+      await statusCache.set(taskId, {
+        inProgress: true
+      });
+      try {
+        await restoreManager.restore(ctx.request.file.path, taskId, getPassword(ctx), true, getSkipRevertOnError(ctx), {
+          forceSchemaRestore: getForceSchemaRestore(ctx)
+        });
+        ctx.body = {
+          status: "ok",
+          task: taskId
+        };
+        await next();
+      } catch (error) {
+        await setRestoreTaskError(statusCache, taskId, error);
+        throw error;
+      } finally {
+        if (uploadedFilePath) {
+          await import_promises.default.unlink(uploadedFilePath).catch(() => {
+          });
+        }
+      }
+    },
+    async restoreStatus(ctx, next) {
+      const statusCache = ctx.app.cacheManager.getCache(import_utils2.RESTORE_TASKS_CACHE_NAME);
+      ctx.body = await statusCache.get(ctx.action.params.task);
+      await next();
+    }
+  }
+};

package/dist/server/resourcers/backups.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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.
+ */
+declare const _default: {
+    name: string;
+    middleware: (ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>) => Promise<any>;
+    actions: {
+        list(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        upload(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        create(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        taskStatus(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        download(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        destroy(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        restore(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        restoreStatus(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+        appInfo(ctx: import("@nocobase/resourcer").ResourcerContext, next: () => Promise<any>): Promise<void>;
+    };
+};
+export default _default;