@tachybase/module-backup 1.5.1 → 1.6.1

package/dist/server/progress-tracker.js

@@ -0,0 +1,286 @@
+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 progress_tracker_exports = {};
+__export(progress_tracker_exports, {
+  ProgressManager: () => ProgressManager
+});
+module.exports = __toCommonJS(progress_tracker_exports);
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
+var import_server = require("@tego/server");
+const _ProgressManager = class _ProgressManager {
+  constructor(backupStorageDir, workDir, app) {
+    this.backupStorageDir = backupStorageDir;
+    this.workDir = workDir;
+    this.app = app;
+  }
+  /**
+   * 获取进度文件路径（静态方法，用于不需要实例的场景）
+   */
+  static getProgressFilePath(filePath) {
+    return filePath + ".progress";
+  }
+  /**
+   * 获取进度文件路径
+   */
+  progressFilePath(fileName, appName) {
+    const progressFile = fileName + ".progress";
+    const dirname = this.backupStorageDir(appName);
+    return import_node_path.default.resolve(dirname, progressFile);
+  }
+  /**
+   * 通过 WebSocket 推送进度更新
+   * @param fileName 备份文件名
+   * @param progress 进度信息
+   * @param userId 用户ID（可选，如果未提供则不会推送，适用于自动备份场景）
+   * @param appName 应用名称
+   */
+  pushProgressViaWebSocket(fileName, progress, userId, appName) {
+    var _a, _b, _c, _d, _e;
+    if (!this.app) {
+      return;
+    }
+    if (!userId || userId <= 0) {
+      if ((_a = this.app) == null ? void 0 : _a.logger) {
+        this.app.logger.debug(`[ProgressManager] Skipping WebSocket push for ${fileName}: no userId`);
+      }
+      return;
+    }
+    try {
+      const gateway = import_server.Gateway.getInstance();
+      const ws = gateway["wsServer"];
+      if (!ws) {
+        if (!_ProgressManager.wsUnavailableWarned) {
+          _ProgressManager.wsUnavailableWarned = true;
+          if ((_b = this.app) == null ? void 0 : _b.logger) {
+            this.app.logger.warn(
+              "[ProgressManager] WebSocket server not available (this is normal in worker threads, progress will be saved to file only)"
+            );
+          }
+        }
+        return;
+      }
+      const finalAppName = appName || this.app.name;
+      const tagPrefix = `app:${finalAppName}`;
+      const tagValue = `${userId}`;
+      const expectedTag = `${tagPrefix}#${tagValue}`;
+      if ((_c = this.app) == null ? void 0 : _c.logger) {
+        const matchingConnections = Array.from(ws.webSocketClients.values()).filter((client) => {
+          var _a2, _b2;
+          return (_b2 = (_a2 = client.tags) == null ? void 0 : _a2.has) == null ? void 0 : _b2.call(_a2, expectedTag);
+        });
+        this.app.logger.debug(
+          `[ProgressManager] Sending backup progress via WebSocket: fileName=${fileName}, userId=${userId}, appName=${finalAppName}, tag=${expectedTag}, progress=${progress.percent}%, matchingConnections=${matchingConnections.length}`
+        );
+        if (matchingConnections.length === 0) {
+          const allTags = Array.from(ws.webSocketClients.values()).flatMap((client) => Array.from(client.tags || [])).filter((tag) => typeof tag === "string" && tag.startsWith("app:"));
+          this.app.logger.warn(
+            `[ProgressManager] No matching connections found for tag ${expectedTag}. Available tags: ${allTags.join(", ")}`
+          );
+        }
+      }
+      try {
+        ws.sendToConnectionsByTag(tagPrefix, tagValue, {
+          type: "backup:progress",
+          payload: {
+            fileName,
+            progress
+          }
+        });
+      } catch (sendError) {
+        if ((_d = this.app) == null ? void 0 : _d.logger) {
+          this.app.logger.error(
+            `[ProgressManager] Failed to send WebSocket message: tagPrefix=${tagPrefix}, tagValue=${tagValue}, error=`,
+            sendError
+          );
+        }
+        throw sendError;
+      }
+    } catch (error) {
+      if ((_e = this.app) == null ? void 0 : _e.logger) {
+        this.app.logger.warn(`[ProgressManager] WebSocket push error for ${fileName} (userId=${userId}):`, error);
+      } else {
+        console.error(`[ProgressManager] WebSocket push error for ${fileName} (userId=${userId}):`, error);
+      }
+    }
+  }
+  /**
+   * 写入进度信息
+   */
+  async writeProgress(fileName, progress, appName, userId) {
+    const filePath = this.progressFilePath(fileName, appName);
+    await import_promises.default.writeFile(filePath, JSON.stringify(progress), "utf8");
+    this.pushProgressViaWebSocket(fileName, progress, userId, appName);
+  }
+  /**
+   * 读取进度信息
+   */
+  async readProgress(fileName, appName) {
+    const filePath = this.progressFilePath(fileName, appName);
+    try {
+      const content = await import_promises.default.readFile(filePath, "utf8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * 清理进度文件
+   */
+  async cleanProgressFile(fileName, appName) {
+    const filePath = this.progressFilePath(fileName, appName);
+    try {
+      await import_promises.default.unlink(filePath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  /**
+   * 创建进度跟踪器
+   */
+  createProgressTracker(backupFileName, appName, userId) {
+    return {
+      /**
+       * 更新进度
+       */
+      update: async (percent, currentStep) => {
+        await this.writeProgress(backupFileName, { percent, currentStep }, appName, userId);
+      },
+      /**
+       * 计算集合备份阶段的进度 (5-70%)
+       */
+      getCollectionProgress: (currentIndex, totalCollections) => {
+        return 5 + Math.floor((currentIndex + 1) / totalCollections * 65);
+      },
+      /**
+       * 计算数据库内容备份阶段的进度 (80-88%)
+       */
+      getDbContentProgress: (processedCollections, totalCollections) => {
+        if (totalCollections === 0) return 80;
+        return 80 + Math.floor(processedCollections / totalCollections * 8);
+      }
+    };
+  }
+  /**
+   * 统计目录中的文件总数
+   */
+  async countFiles(dir) {
+    let count = 0;
+    try {
+      const entries = await import_promises.default.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = import_node_path.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          count += await this.countFiles(fullPath);
+        } else {
+          count++;
+        }
+      }
+    } catch (error) {
+    }
+    return count;
+  }
+  /**
+   * 设置打包阶段的进度更新
+   */
+  setupPackingProgress(archive, progressTracker) {
+    let processedEntries = 0;
+    let totalEntries = 0;
+    let startTime = Date.now();
+    let progressInterval = null;
+    let currentProgress = 90;
+    let isFinished = false;
+    this.countFiles(this.workDir).then((count) => {
+      totalEntries = count || 1;
+    }).catch(() => {
+      totalEntries = 1;
+    });
+    archive.on("entry", () => {
+      processedEntries++;
+    });
+    const handleFinish = async () => {
+      var _a;
+      if (isFinished) {
+        return;
+      }
+      isFinished = true;
+      if (progressInterval) {
+        clearInterval(progressInterval);
+        progressInterval = null;
+      }
+      try {
+        await progressTracker.update(99, "Packing backup file...");
+      } catch (error) {
+        if ((_a = this.app) == null ? void 0 : _a.logger) {
+          this.app.logger.warn("[ProgressManager] Failed to update progress after packing:", error);
+        }
+      }
+    };
+    archive.on("end", handleFinish);
+    archive.on("finish", handleFinish);
+    progressInterval = setInterval(async () => {
+      if (isFinished) {
+        if (progressInterval) {
+          clearInterval(progressInterval);
+          progressInterval = null;
+        }
+        return;
+      }
+      const elapsed = Date.now() - startTime;
+      if (processedEntries > 0 && totalEntries > 0) {
+        const fileBasedProgress = 90 + Math.floor(processedEntries / totalEntries * 9);
+        const timeBasedProgress = Math.min(90 + Math.floor(elapsed / 6e4 * 9), 99);
+        currentProgress = Math.max(currentProgress, Math.min(fileBasedProgress, timeBasedProgress, 99));
+      } else {
+        currentProgress = Math.min(90 + Math.floor(elapsed / 6e4 * 9), 99);
+      }
+      if (currentProgress < 99) {
+        await progressTracker.update(currentProgress, "Packing backup file...");
+      }
+    }, 300);
+    return () => {
+      isFinished = true;
+      if (progressInterval) {
+        clearInterval(progressInterval);
+        progressInterval = null;
+      }
+    };
+  }
+};
+// 静态标志，用于避免重复警告 WebSocket 不可用（在 worker 线程中很常见）
+_ProgressManager.wsUnavailableWarned = false;
+let ProgressManager = _ProgressManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProgressManager
+});

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

@@ -57,15 +57,15 @@ var backup_files_default = {
   actions: {
     async list(ctx, next) {
       const { page = import_server.DEFAULT_PAGE, pageSize = import_server.DEFAULT_PER_PAGE } = ctx.action.params;
-      const dumper = new import_dumper.Dumper(ctx.app);
+      const dumper = new import_dumper.Dumper(ctx.tego);
       const backupFiles = await dumper.allBackUpFilePaths({
         includeInProgress: true,
-        appName: ctx.app.name
+        appName: ctx.tego.name
       });
       const count = backupFiles.length;
       const rows = await Promise.all(
         backupFiles.slice((page - 1) * pageSize, page * pageSize).map(async (file) => {
-          return await import_dumper.Dumper.getFileStatus(file.endsWith(".lock") ? file.replace(".lock", "") : file);
+          return await import_dumper.Dumper.getFileStatus(file.endsWith(".lock") ? file.replace(".lock", "") : file, ctx.tego.name);
         })
       );
       ctx.body = {
@@ -79,8 +79,8 @@ var backup_files_default = {
     },
     async get(ctx, next) {
       const { filterByTk } = ctx.action.params;
-      const dumper = new import_dumper.Dumper(ctx.app);
-      const filePath = dumper.backUpFilePath(filterByTk, ctx.app.name);
+      const dumper = new import_dumper.Dumper(ctx.tego);
+      const filePath = dumper.backUpFilePath(filterByTk, ctx.tego.name);
       async function sendError(message, status = 404) {
         ctx.body = { status: "error", message };
         ctx.status = status;
@@ -90,7 +90,7 @@ var backup_files_default = {
         if (fileState.status !== "ok") {
           await sendError(`Backup file ${filterByTk} not found`);
         } else {
-          const restorer = new import_restorer.Restorer(ctx.app, {
+          const restorer = new import_restorer.Restorer(ctx.tego, {
             backUpFilePath: filePath
           });
           const restoreMeta = await restorer.parseBackupFile();
@@ -112,24 +112,26 @@ var backup_files_default = {
      * @param next
      */
     async create(ctx, next) {
-      var _a, _b;
+      var _a, _b, _c;
       const data = ctx.request.body;
-      const app = ctx.app;
-      if (data.method === "worker" && !((_a = app.worker) == null ? void 0 : _a.available)) {
+      const app = ctx.tego;
+      const userId = (_a = ctx.state.currentUser) == null ? void 0 : _a.id;
+      if (data.method === "worker" && !((_b = app.worker) == null ? void 0 : _b.available)) {
         ctx.throw(500, ctx.t("No worker thread", { ns: "worker-thread" }));
         return next();
       }
-      let useWorker = data.method === "worker" || data.method === "priority" && ((_b = app.worker) == null ? void 0 : _b.available);
-      const dumper = new import_dumper.Dumper(ctx.app);
-      const taskId = await dumper.getLockFile(ctx.app.name);
+      let useWorker = data.method === "worker" || data.method === "priority" && ((_c = app.worker) == null ? void 0 : _c.available);
+      const dumper = new import_dumper.Dumper(ctx.tego);
+      const taskId = await dumper.getLockFile(ctx.tego.name);
       if (useWorker) {
         app.worker.callPluginMethod({
           plugin: import_server2.default,
           method: "workerCreateBackUp",
           params: {
             dataTypes: data.dataTypes,
-            appName: ctx.app.name,
-            filename: taskId
+            appName: ctx.tego.name,
+            filename: taskId,
+            userId
           },
           // 目前限制方法并发为1
           concurrency: 1
@@ -138,20 +140,21 @@ var backup_files_default = {
         }).catch((error) => {
           app.noticeManager.notify("backup", { level: "error", msg: error.message });
         }).finally(() => {
-          dumper.cleanLockFile(taskId, ctx.app.name);
+          dumper.cleanLockFile(taskId, ctx.tego.name);
         });
       } else {
         const plugin = app.pm.get(import_server2.default);
         plugin.workerCreateBackUp({
           dataTypes: data.dataTypes,
-          appName: ctx.app.name,
-          filename: taskId
+          appName: ctx.tego.name,
+          filename: taskId,
+          userId
         }).then((res) => {
           app.noticeManager.notify("backup", { level: "info", msg: ctx.t("Done", { ns: "backup" }) });
         }).catch((error) => {
           app.noticeManager.notify("backup", { level: "error", msg: error.message });
         }).finally(() => {
-          dumper.cleanLockFile(taskId, ctx.app.name);
+          dumper.cleanLockFile(taskId, ctx.tego.name);
         });
       }
       ctx.body = {
@@ -166,8 +169,8 @@ var backup_files_default = {
      */
     async download(ctx, next) {
       const { filterByTk } = ctx.action.params;
-      const dumper = new import_dumper.Dumper(ctx.app);
-      const filePath = dumper.backUpFilePath(filterByTk, ctx.app.name);
+      const dumper = new import_dumper.Dumper(ctx.tego);
+      const filePath = dumper.backUpFilePath(filterByTk, ctx.tego.name);
       const fileState = await import_dumper.Dumper.getFileStatus(filePath);
       if (fileState.status !== "ok") {
         throw new Error(`Backup file ${filterByTk} not found`);
@@ -187,8 +190,8 @@ var backup_files_default = {
           return import_node_path.default.resolve(tmpDir, key);
         }
         if (filterByTk) {
-          const dumper = new import_dumper.Dumper(ctx.app);
-          return dumper.backUpFilePath(filterByTk, ctx.app.name);
+          const dumper = new import_dumper.Dumper(ctx.tego);
+          return dumper.backUpFilePath(filterByTk, ctx.tego.name);
         }
       })();
       if (!filePath) {
@@ -198,13 +201,13 @@ var backup_files_default = {
       for (const dataType of dataTypes) {
         args.push("-g", dataType);
       }
-      await ctx.app.runCommand(...args);
+      await ctx.tego.runCommand(...args);
       await next();
     },
     async destroy(ctx, next) {
       const { filterByTk } = ctx.action.params;
-      const dumper = new import_dumper.Dumper(ctx.app);
-      const filePath = dumper.backUpFilePath(filterByTk, ctx.app.name);
+      const dumper = new import_dumper.Dumper(ctx.tego);
+      const filePath = dumper.backUpFilePath(filterByTk, ctx.tego.name);
       await import_promises.default.unlink(filePath);
       ctx.body = {
         status: "ok"
@@ -214,7 +217,7 @@ var backup_files_default = {
     async upload(ctx, next) {
       const file = ctx.file;
       const fileName = file.filename;
-      const restorer = new import_restorer.Restorer(ctx.app, {
+      const restorer = new import_restorer.Restorer(ctx.tego, {
         backUpFilePath: file.path
       });
       const restoreMeta = await restorer.parseBackupFile();
@@ -226,7 +229,7 @@ var backup_files_default = {
     },
     async dumpableCollections(ctx, next) {
       ctx.withoutDataWrapping = true;
-      const dumper = new import_dumper.Dumper(ctx.app);
+      const dumper = new import_dumper.Dumper(ctx.tego);
       ctx.body = await dumper.dumpableCollectionsGroupByGroup();
       await next();
     }

package/dist/server/server.d.ts

@@ -15,5 +15,6 @@ export default class PluginBackupRestoreServer extends Plugin {
         dataTypes: string[];
         appName: string;
         filename: string;
+        userId?: number;
     }): Promise<void>;
 }

package/dist/server/server.js

@@ -57,6 +57,53 @@ const _PluginBackupRestoreServer = class _PluginBackupRestoreServer extends impo
   }
   async load() {
     this.app.resourcer.define(import_backup_files.default);
+    const gateway = import_server.Gateway.getInstance();
+    const ws = gateway["wsServer"];
+    if (ws == null ? void 0 : ws.wss) {
+      const appName = this.app.name;
+      ws.wss.on(
+        "connection",
+        async (websocket) => {
+          websocket.on("message", async (data) => {
+            var _a, _b, _c;
+            if (data.toString() !== "ping") {
+              try {
+                const userMeg = JSON.parse(data.toString());
+                if (userMeg.type === "signIn") {
+                  if (!((_a = userMeg.payload) == null ? void 0 : _a.token)) {
+                    return;
+                  }
+                  try {
+                    const analysis = await ((_c = (_b = this.app.authManager) == null ? void 0 : _b.jwt) == null ? void 0 : _c.verifyToken(userMeg.payload.token));
+                    const userId = analysis.userId;
+                    const client = ws.webSocketClients.get(websocket.id);
+                    if (client) {
+                      client.tags.forEach((tag2) => {
+                        if (tag2.startsWith("app:")) {
+                          client.tags.delete(tag2);
+                        }
+                      });
+                      const tag = `app:${appName}#${userId}`;
+                      client.tags.add(tag);
+                      this.app.logger.debug(`[Backup] WebSocket signIn: set tag ${tag} for connection ${websocket.id}`);
+                    } else {
+                      this.app.logger.warn(
+                        `[Backup] WebSocket signIn: client not found for connection ${websocket.id}`
+                      );
+                    }
+                  } catch (error) {
+                    this.app.logger.warn("[Backup] WebSocket signIn message connection error:", error);
+                  }
+                }
+              } catch (error) {
+              }
+            }
+          });
+        }
+      );
+    } else {
+      this.app.logger.warn("[Backup] WebSocket server not available, backup progress will not be pushed via WebSocket");
+    }
     this.app.on("afterStart", async (app) => {
       const cronJobs = await app.db.getRepository(import_constants.COLLECTION_AUTOBACKUP).find({
         filter: { enabled: true }
@@ -228,7 +275,8 @@ const _PluginBackupRestoreServer = class _PluginBackupRestoreServer extends impo
     await new import_dumper.Dumper(this.app).runDumpTask({
       groups: new Set(data.dataTypes),
       appName: data.appName,
-      fileName: data.filename
+      fileName: data.filename,
+      userId: data.userId
     });
   }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tachybase/module-backup",
   "displayName": "App backup & restore",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "Backup and restore applications for scenarios such as application replication, migration, and upgrades.",
   "keywords": [
     "System management"
@@ -9,12 +9,12 @@
   "license": "Apache-2.0",
   "main": "./dist/server/index.js",
   "devDependencies": {
-    "@ant-design/icons": "^5.6.1",
+    "@ant-design/icons": "^6.1.0",
     "@hapi/topo": "^6.0.2",
-    "@tachybase/schema": "1.3.52",
-    "@tachybase/test": "1.3.52",
-    "@tego/client": "1.3.52",
-    "@tego/server": "1.3.52",
+    "@tachybase/schema": "1.6.0-alpha.9",
+    "@tachybase/test": "1.6.0-alpha.9",
+    "@tego/client": "1.6.0-alpha.9",
+    "@tego/server": "1.6.0-alpha.9",
     "@types/archiver": "^5.3.4",
     "@types/file-saver": "^2.0.7",
     "@types/lodash": "^4.17.20",
@@ -34,8 +34,8 @@
     "semver": "7.7.2",
     "tar": "^7.4.3",
     "yauzl": "^3.2.0",
-    "@tachybase/client": "1.5.1",
-    "@tachybase/module-worker-thread": "1.5.1"
+    "@tachybase/client": "1.6.1",
+    "@tachybase/module-worker-thread": "1.6.1"
   },
   "description.zh-CN": "备份和还原应用，可用于应用的复制、迁移、升级等场景。",
   "displayName.zh-CN": "应用的备份与还原",