@nocobase/plugin-backups 2.0.56

package/dist/server/resourcers/backups.js

@@ -0,0 +1,192 @@
+/**
+ * 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 backups_exports = {};
+__export(backups_exports, {
+  default: () => backups_default
+});
+module.exports = __toCommonJS(backups_exports);
+var import_utils = require("@nocobase/utils");
+var import_promises = __toESM(require("fs/promises"));
+var import_os = __toESM(require("os"));
+var import_backup = require("../managers/backup");
+var import_utils2 = require("../utils");
+var import_restore = require("../managers/restore");
+var import_crypto = __toESM(require("crypto"));
+async function setRestoreTaskError(statusCache, taskId, error) {
+  await statusCache.set(taskId, {
+    inProgress: false,
+    message: error instanceof Error ? error.message : String(error)
+  });
+}
+var backups_default = {
+  name: "backups",
+  middleware: async (ctx, next) => {
+    if (ctx.action.actionName !== "upload") {
+      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);
+      const backups = await backupManager.list();
+      ctx.body = backups;
+      await next();
+    },
+    async upload(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.restoreFromUpload(ctx.request.file, taskId, ctx.request.body.password, true);
+        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 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 taskStatus(ctx, next) {
+      const statusCache = ctx.app.cacheManager.getCache(import_utils2.BACKUP_TASKS_CACHE_NAME);
+      const backupNames = ctx.action.params.names;
+      const results = await statusCache.mget(...backupNames);
+      ctx.body = backupNames.reduce(
+        (acc, name, index) => {
+          acc[name] = results[index];
+          return acc;
+        },
+        {}
+      );
+      await next();
+    },
+    async download(ctx, next) {
+      const backupSettings = await ctx.db.getRepository(import_utils2.SETTINGS).findOne();
+      const backupManager = new import_backup.BackupManager(ctx.app, ctx, backupSettings);
+      const fileName = ctx.action.params.filterByTk;
+      ctx.attachment(fileName);
+      ctx.body = await backupManager.createReadStream(fileName);
+      await next();
+    },
+    async destroy(ctx, next) {
+      const backupSettings = await ctx.db.getRepository(import_utils2.SETTINGS).findOne();
+      const backupManager = new import_backup.BackupManager(ctx.app, ctx, backupSettings);
+      await backupManager.destroy(ctx.action.params.filterByTk);
+      ctx.body = {
+        status: "ok"
+      };
+      await next();
+    },
+    async restore(ctx, next) {
+      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.restoreFromBackup(ctx.request.body.name, taskId, ctx.request.body.password, true);
+        ctx.body = {
+          status: "ok",
+          task: taskId
+        };
+        await next();
+      } catch (error) {
+        await setRestoreTaskError(statusCache, taskId, error);
+        throw error;
+      }
+    },
+    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();
+    },
+    async appInfo(ctx, next) {
+      const { dialect, schema } = ctx.app.db.options;
+      ctx.body = {
+        database: { dialect, schema }
+      };
+      await next();
+    }
+  }
+};

package/dist/server/types.d.ts

@@ -0,0 +1,12 @@
+export interface StorageModel {
+    id?: number;
+    title: string;
+    type: string;
+    name: string;
+    baseUrl: string;
+    options: Record<string, any>;
+    rules?: Record<string, any>;
+    path?: string;
+    default?: boolean;
+    paranoid?: boolean;
+}

package/dist/server/types.js

@@ -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.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/server/utils.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+export declare const BACKUP_EXTENSION = "nbdata";
+export declare const STORAGE_PATH = "storage/uploads";
+export declare const SETTINGS = "backupSettings";
+export declare const BACKUPS = "backups";
+export declare const FILE_ENCRYPTION_SALT = "backup salt";
+export declare const BACKUP_TASKS_CACHE_NAME = "backup-task-results";
+export declare const RESTORE_TASKS_CACHE_NAME = "restore-task-results";
+export declare const RESTORE_TASKS_CACHE_TTL: number;
+import { Writable, Transform, TransformCallback } from 'stream';
+import Database from '@nocobase/database';
+export declare const PLUGIN_BACKUPS_NAME: string;
+export declare function resolvePathWithinBase(basePath: string, unsafePath: string): string | undefined;
+export declare class Extractor extends Writable {
+    private tempFile;
+    private extractPath;
+    private tempWriteStream;
+    constructor(options: {
+        path: string;
+    });
+    _write(chunk: any, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+    _final(callback: (error?: Error | null) => void): void;
+    private extract;
+    promise(): 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;
+export declare function toMajorVersion(raw: string): string | undefined;
+/**
+ * Transform stream that replaces \' with '' while properly handling UTF-8 character boundaries
+ * This prevents issues when restoring MySQL backups on Windows
+ */
+export declare class EscapeQuoteTransform extends Transform {
+    private bufferBytes;
+    constructor();
+    _transform(chunk: Buffer, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: Function): void;
+}

package/dist/server/utils.js

@@ -0,0 +1,323 @@
+/**
+ * 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 name2 in all)
+    __defProp(target, name2, { get: all[name2], 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 utils_exports = {};
+__export(utils_exports, {
+  BACKUPS: () => BACKUPS,
+  BACKUP_EXTENSION: () => BACKUP_EXTENSION,
+  BACKUP_TASKS_CACHE_NAME: () => BACKUP_TASKS_CACHE_NAME,
+  EscapeQuoteTransform: () => EscapeQuoteTransform,
+  Extractor: () => Extractor,
+  FILE_ENCRYPTION_SALT: () => FILE_ENCRYPTION_SALT,
+  PLUGIN_BACKUPS_NAME: () => PLUGIN_BACKUPS_NAME,
+  RESTORE_TASKS_CACHE_NAME: () => RESTORE_TASKS_CACHE_NAME,
+  RESTORE_TASKS_CACHE_TTL: () => RESTORE_TASKS_CACHE_TTL,
+  SETTINGS: () => SETTINGS,
+  STORAGE_PATH: () => STORAGE_PATH,
+  getDBVersion: () => getDBVersion,
+  humanFileSize: () => humanFileSize,
+  isQsTruly: () => isQsTruly,
+  resolvePathWithinBase: () => resolvePathWithinBase,
+  toMajorVersion: () => toMajorVersion
+});
+module.exports = __toCommonJS(utils_exports);
+var import_stream = require("stream");
+var import_yauzl = __toESM(require("yauzl"));
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = __toESM(require("path"));
+var import_sequelize = require("sequelize");
+var import_package = require("../../package.json");
+const BACKUP_EXTENSION = "nbdata";
+const STORAGE_PATH = "storage/uploads";
+const SETTINGS = "backupSettings";
+const BACKUPS = "backups";
+const FILE_ENCRYPTION_SALT = "backup salt";
+const BACKUP_TASKS_CACHE_NAME = "backup-task-results";
+const RESTORE_TASKS_CACHE_NAME = "restore-task-results";
+const RESTORE_TASKS_CACHE_TTL = 24 * 60 * 60 * 1e3;
+const PLUGIN_BACKUPS_NAME = import_package.name;
+function resolvePathWithinBase(basePath, unsafePath) {
+  const resolvedBasePath = import_path.default.resolve(basePath);
+  const resolvedTargetPath = import_path.default.resolve(resolvedBasePath, unsafePath);
+  const relativePath = import_path.default.relative(resolvedBasePath, resolvedTargetPath);
+  if (relativePath === "" || relativePath === "." || relativePath === ".." || relativePath.startsWith(`..${import_path.default.sep}`) || import_path.default.isAbsolute(relativePath)) {
+    return void 0;
+  }
+  return resolvedTargetPath;
+}
+class Extractor extends import_stream.Writable {
+  tempFile;
+  extractPath;
+  tempWriteStream = null;
+  constructor(options) {
+    super();
+    this.extractPath = options.path;
+    this.tempFile = import_path.default.join(this.extractPath, `temp_${Date.now()}.zip`);
+  }
+  _write(chunk, encoding, callback) {
+    if (!this.tempWriteStream) {
+      import_fs_extra.default.mkdirp(import_path.default.dirname(this.tempFile), (error) => {
+        if (error) {
+          callback(error);
+          return;
+        }
+        this.tempWriteStream = import_fs_extra.default.createWriteStream(this.tempFile);
+        this.tempWriteStream.write(chunk, encoding, callback);
+      });
+    } else {
+      this.tempWriteStream.write(chunk, encoding, callback);
+    }
+  }
+  _final(callback) {
+    if (!this.tempWriteStream) {
+      callback();
+      return;
+    }
+    this.tempWriteStream.end(() => {
+      this.extract((error) => {
+        if (error) {
+          callback(error);
+          return;
+        }
+        import_fs_extra.default.unlink(this.tempFile, callback);
+      });
+    });
+  }
+  extract(callback) {
+    import_yauzl.default.open(this.tempFile, { lazyEntries: true }, (error, zipfile) => {
+      if (error) {
+        callback(error);
+        return;
+      }
+      if (!zipfile) {
+        callback(new Error("Failed to open zip file"));
+        return;
+      }
+      let settled = false;
+      const done = (err) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        zipfile.removeAllListeners();
+        if (err) {
+          zipfile.close();
+        }
+        callback(err);
+      };
+      zipfile.on("error", done);
+      zipfile.on("end", () => done());
+      zipfile.on("entry", (entry) => {
+        const fullPath = resolvePathWithinBase(this.extractPath, entry.fileName);
+        if (!fullPath) {
+          done(new Error(`Invalid zip entry path: ${entry.fileName}`));
+          return;
+        }
+        if (entry.fileName.endsWith("/")) {
+          import_fs_extra.default.mkdirp(fullPath, (mkdirError) => {
+            if (mkdirError) {
+              done(mkdirError);
+              return;
+            }
+            if (!settled) {
+              zipfile.readEntry();
+            }
+          });
+          return;
+        }
+        import_fs_extra.default.mkdirp(import_path.default.dirname(fullPath), (mkdirError) => {
+          if (mkdirError) {
+            done(mkdirError);
+            return;
+          }
+          zipfile.openReadStream(entry, (readError, readStream) => {
+            if (readError) {
+              done(readError);
+              return;
+            }
+            if (!readStream) {
+              done(new Error("Failed to open read stream"));
+              return;
+            }
+            const writeStream = import_fs_extra.default.createWriteStream(fullPath);
+            readStream.on("error", done);
+            writeStream.on("error", done);
+            writeStream.on("finish", () => {
+              if (!settled) {
+                zipfile.readEntry();
+              }
+            });
+            readStream.pipe(writeStream);
+          });
+        });
+      });
+      zipfile.readEntry();
+    });
+  }
+  promise() {
+    return new Promise((resolve, reject) => {
+      this.on("finish", resolve);
+      this.on("error", reject);
+    });
+  }
+}
+function humanFileSize(bytes, si = false, dp = 1) {
+  const thresh = si ? 1e3 : 1024;
+  const units = si ? ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"] : ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
+  let u = 0;
+  while (Math.abs(bytes) >= thresh && u < units.length - 1) {
+    bytes /= thresh;
+    u++;
+  }
+  return bytes.toFixed(dp) + " " + units[u];
+}
+const dbVersionCommands = {
+  sqlite: "select sqlite_version() as version",
+  mysql: "select version() as version",
+  mariadb: "select version() as version",
+  postgres: "select version() as version"
+};
+async function getDBVersion(db) {
+  var _a;
+  const dialect = db.sequelize.getDialect();
+  const sqlCmd = dbVersionCommands[dialect];
+  if (!sqlCmd) {
+    throw new Error(`unsupported dialect ${dialect}`);
+  }
+  const result = await db.sequelize.query(sqlCmd, {
+    type: import_sequelize.QueryTypes.SELECT
+  });
+  return ((_a = result == null ? void 0 : result[0]) == null ? void 0 : _a.version) || "";
+}
+function isQsTruly(value) {
+  try {
+    return !!value && JSON.parse(`${value}`.toLowerCase());
+  } catch (_e) {
+    return false;
+  }
+}
+function toMajorVersion(raw) {
+  const m = /([\d+.]+)/.exec(raw);
+  return m != null ? m[0].replace(/\..+$/, "") : void 0;
+}
+class EscapeQuoteTransform extends import_stream.Transform {
+  bufferBytes = Buffer.alloc(0);
+  constructor() {
+    super({ objectMode: false });
+  }
+  _transform(chunk, _encoding, callback) {
+    try {
+      const buffers = [this.bufferBytes, chunk];
+      this.bufferBytes = Buffer.concat(buffers);
+      let processBytes = this.bufferBytes;
+      let remainingBytes = Buffer.alloc(0);
+      for (let i = Math.max(0, this.bufferBytes.length - 4); i < this.bufferBytes.length; i++) {
+        const byte = this.bufferBytes[i];
+        if ((byte & 128) === 0) {
+          continue;
+        } else if ((byte & 224) === 192) {
+          if (i + 1 >= this.bufferBytes.length) {
+            processBytes = this.bufferBytes.subarray(0, i);
+            remainingBytes = this.bufferBytes.subarray(i);
+            break;
+          }
+        } else if ((byte & 240) === 224) {
+          if (i + 2 >= this.bufferBytes.length) {
+            processBytes = this.bufferBytes.subarray(0, i);
+            remainingBytes = this.bufferBytes.subarray(i);
+            break;
+          }
+        } else if ((byte & 248) === 240) {
+          if (i + 3 >= this.bufferBytes.length) {
+            processBytes = this.bufferBytes.subarray(0, i);
+            remainingBytes = this.bufferBytes.subarray(i);
+            break;
+          }
+        }
+      }
+      if (processBytes.length > 0) {
+        let text = processBytes.toString("utf8");
+        if (text.endsWith("\\")) {
+          const lastBackslashIndex = text.lastIndexOf("\\");
+          const beforeBackslash = text.slice(0, lastBackslashIndex);
+          const backslashPart = text.slice(lastBackslashIndex);
+          const backslashBytes = Buffer.from(backslashPart, "utf8");
+          remainingBytes = Buffer.concat([backslashBytes, remainingBytes]);
+          text = beforeBackslash;
+        }
+        if (text) {
+          const processed = text.replace(/\\'/g, "''");
+          this.push(Buffer.from(processed, "utf8"));
+        }
+      }
+      this.bufferBytes = remainingBytes;
+      callback();
+    } catch (error) {
+      callback(error);
+    }
+  }
+  _flush(callback) {
+    try {
+      if (this.bufferBytes.length > 0) {
+        const text = this.bufferBytes.toString("utf8");
+        const processed = text.replace(/\\'/g, "''");
+        this.push(Buffer.from(processed, "utf8"));
+      }
+      callback();
+    } catch (error) {
+      callback(error);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BACKUPS,
+  BACKUP_EXTENSION,
+  BACKUP_TASKS_CACHE_NAME,
+  EscapeQuoteTransform,
+  Extractor,
+  FILE_ENCRYPTION_SALT,
+  PLUGIN_BACKUPS_NAME,
+  RESTORE_TASKS_CACHE_NAME,
+  RESTORE_TASKS_CACHE_TTL,
+  SETTINGS,
+  STORAGE_PATH,
+  getDBVersion,
+  humanFileSize,
+  isQsTruly,
+  resolvePathWithinBase,
+  toMajorVersion
+});