@tachybase/module-backup 1.0.18 → 1.1.0

package/dist/server/collections/autoBackup.d.ts

@@ -0,0 +1,2 @@
+import { CollectionOptions } from '@tachybase/database';
+export default function (): CollectionOptions;

package/dist/server/collections/autoBackup.js

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var autoBackup_exports = {};
+__export(autoBackup_exports, {
+  default: () => autoBackup_default
+});
+module.exports = __toCommonJS(autoBackup_exports);
+var import_constants = require("../../constants");
+function autoBackup_default() {
+  return {
+    dumpRules: "required",
+    name: import_constants.COLLECTION_AUTOBACKUP,
+    shared: true,
+    createdAt: true,
+    updatedAt: true,
+    createdBy: true,
+    updatedBy: true,
+    fields: [
+      {
+        type: "string",
+        name: "title",
+        required: true
+      },
+      {
+        type: "boolean",
+        name: "enabled",
+        defaultValue: false
+      },
+      {
+        type: "string",
+        name: "repeat"
+      },
+      {
+        type: "array",
+        name: "dumpRules"
+      },
+      {
+        type: "integer",
+        name: "maxNumber"
+      },
+      {
+        type: "encryption",
+        name: "password",
+        interface: "encryption",
+        iv: "welljzlyq2p2439v"
+      }
+    ]
+  };
+}

package/dist/server/commands/backup-command.d.ts

@@ -0,0 +1,2 @@
+import { Application } from '@tachybase/server';
+export default function addBackupCommand(app: Application): void;

package/dist/server/commands/backup-command.js

@@ -0,0 +1,78 @@
+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_command_exports = {};
+__export(backup_command_exports, {
+  default: () => addBackupCommand
+});
+module.exports = __toCommonJS(backup_command_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_server = require("@tachybase/server");
+var import_dumper = require("../dumper");
+function addBackupCommand(app) {
+  app.command("backup").ipc().option("-a, --app <appName>", "sub app name if you want to backup").option(
+    "-g, --groups <groups>",
+    "groups to backup",
+    (value, previous) => {
+      return previous.concat([value]);
+    },
+    []
+  ).action(async (options) => {
+    let backupApp = app;
+    if (options.app) {
+      if (!await app.db.getCollection("applications").repository.findOne({
+        filter: { name: options.app }
+      })) {
+        await app.db.getCollection("applications").repository.create({
+          values: {
+            name: options.app
+          }
+        });
+      }
+      const subApp = await import_server.AppSupervisor.getInstance().getApp(options.app);
+      if (!subApp) {
+        app.logger.error(`app ${options.app} not found`);
+        await app.stop();
+        return;
+      }
+      backupApp = subApp;
+    }
+    const groups = new Set(options.groups);
+    groups.add("required");
+    const dumper = new import_dumper.Dumper(app);
+    const appName = backupApp.name;
+    const backupFileName = import_dumper.Dumper.generateFileName();
+    const tmpFile = await dumper.writeLockFile(backupFileName, appName);
+    await dumper.runDumpTask({
+      groups,
+      appName,
+      fileName: backupFileName
+    });
+    await import_promises.default.unlink(tmpFile);
+    backupApp.logger.info(`${appName} backup into ${backupFileName}!`);
+  });
+}

package/dist/server/dumper.d.ts

@@ -54,7 +54,7 @@ export declare class Dumper extends AppMigrator {
     }): Promise<string[]>;
     backUpFilePath(fileName: string, appName?: string): string;
     lockFilePath(fileName: string, appName?: string): string;
-    writeLockFile(fileName: string, appName?: string): Promise<void>;
+    writeLockFile(fileName: string, appName?: string): Promise<string>;
     cleanLockFile(fileName: string, appName: string): Promise<void>;
     getLockFile(appName: string): Promise<string>;
     runDumpTask(options: DumpOptions): Promise<void>;

package/dist/server/dumper.js

@@ -189,6 +189,7 @@ const _Dumper = class _Dumper extends import_app_migrator.AppMigrator {
     await (0, import_mkdirp.default)(dirname);
     const filePath = this.lockFilePath(fileName, appName);
     await import_promises.default.writeFile(filePath, "lock", "utf8");
+    return filePath;
   }
   async cleanLockFile(fileName, appName) {
     const filePath = this.lockFilePath(fileName, appName);

package/dist/server/model/AutoBackupModel.d.ts

@@ -0,0 +1,15 @@
+import { Model } from '@tachybase/database';
+export declare class AutoBackupModel extends Model {
+    id: number;
+    title: string;
+    startsOn: Date;
+    endsOn?: Date;
+    repeat: string;
+    enabled: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    allExecuted: number;
+    password: string;
+    dumpRules: string;
+    maxNumber: number;
+}

package/dist/server/model/AutoBackupModel.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AutoBackupModel_exports = {};
+__export(AutoBackupModel_exports, {
+  AutoBackupModel: () => AutoBackupModel
+});
+module.exports = __toCommonJS(AutoBackupModel_exports);
+var import_database = require("@tachybase/database");
+class AutoBackupModel extends import_database.Model {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutoBackupModel
+});

package/dist/server/server.d.ts

@@ -1,7 +1,16 @@
 import { Plugin } from '@tachybase/server';
+import { AutoBackupModel } from './model/AutoBackupModel';
 export default class PluginBackupRestoreServer extends Plugin {
+    private static readonly inspectFields;
     beforeLoad(): void;
+    private timers;
     load(): Promise<void>;
+    inspect(cronJobs: AutoBackupModel[]): void;
+    getNextTime(cronJob: AutoBackupModel, currentDate: Date, nextSecond?: boolean): number;
+    schedule(cronJob: AutoBackupModel, nextTime: number, toggle?: boolean): void;
+    trigger(cronJobId: number, time: number): Promise<void>;
+    on(cronJob: AutoBackupModel): void;
+    off(cronJob: AutoBackupModel): void;
     workerCreateBackUp(data: {
         dataTypes: string[];
         appName: string;

package/dist/server/server.js

@@ -31,17 +31,194 @@ __export(server_exports, {
 });
 module.exports = __toCommonJS(server_exports);
 var import_server = require("@tachybase/server");
+var import_cron_parser = __toESM(require("cron-parser"));
+var import_constants = require("../constants");
 var import_dumper = require("./dumper");
 var import_backup_files = __toESM(require("./resourcers/backup-files"));
-class PluginBackupRestoreServer extends import_server.Plugin {
+var import_files = require("./utils/files");
+function parseDateWithoutMs(date) {
+  return Math.floor(date.getTime() / 1e3) * 1e3;
+}
+const MAX_SAFE_INTERVAL = 2147483647;
+const _PluginBackupRestoreServer = class _PluginBackupRestoreServer extends import_server.Plugin {
+  constructor() {
+    super(...arguments);
+    this.timers = /* @__PURE__ */ new Map();
+  }
   beforeLoad() {
     this.app.acl.registerSnippet({
-      name: `pm.${this.name}`,
+      name: `pm.${this.name}.files`,
       actions: ["backupFiles:*"]
     });
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.auto`,
+      actions: ["autoBackup:*"]
+    });
   }
   async load() {
     this.app.resourcer.define(import_backup_files.default);
+    this.app.on("afterStart", async (app) => {
+      const cronJobs = await app.db.getRepository(import_constants.COLLECTION_AUTOBACKUP).find({
+        filter: { enabled: true }
+      });
+      this.inspect(cronJobs);
+    });
+    this.app.on("beforeStop", () => {
+      for (const timer of this.timers.values()) {
+        clearInterval(timer);
+      }
+    });
+    this.db.on(`${import_constants.COLLECTION_AUTOBACKUP}.beforeSave`, async (cronjob, options) => {
+      let changed = false;
+      for (const field of options.fields) {
+        if (_PluginBackupRestoreServer.inspectFields.includes(field)) {
+          changed = true;
+          break;
+        }
+      }
+      if (!changed) {
+        return;
+      }
+      this.off(cronjob);
+    });
+    this.db.on(`${import_constants.COLLECTION_AUTOBACKUP}.afterSave`, async (cronjob, options) => {
+      let changed = false;
+      for (const field of options.fields) {
+        if (_PluginBackupRestoreServer.inspectFields.includes(field)) {
+          changed = true;
+          break;
+        }
+      }
+      if (!changed) {
+        return;
+      }
+      if (cronjob.get("enabled")) {
+        this.on(cronjob);
+      }
+    });
+    this.db.on(`${import_constants.COLLECTION_AUTOBACKUP}.afterDestroy`, async (cronjob) => {
+      this.off(cronjob);
+    });
+  }
+  inspect(cronJobs) {
+    const now = /* @__PURE__ */ new Date();
+    cronJobs.forEach((cronJob) => {
+      const nextTime = this.getNextTime(cronJob, now);
+      if (nextTime) {
+        this.app.logger.info(
+          `cronJobs [${cronJob.id}] caching scheduled will run at: ${new Date(nextTime).toISOString()}`
+        );
+      } else {
+        this.app.logger.info(`cronJobs [${cronJob.id}] will not be scheduled`);
+      }
+      this.schedule(cronJob, nextTime, nextTime >= now.getTime());
+    });
+  }
+  getNextTime(cronJob, currentDate, nextSecond = false) {
+    currentDate.setMilliseconds(nextSecond ? 1e3 : 0);
+    const timestamp = currentDate.getTime();
+    const startTime = parseDateWithoutMs(cronJob.startsOn || /* @__PURE__ */ new Date());
+    if (startTime > timestamp) {
+      return startTime;
+    }
+    if (cronJob.repeat) {
+      const endTime = cronJob.endsOn ? parseDateWithoutMs(cronJob.endsOn) : null;
+      if (endTime && endTime < timestamp) {
+        return null;
+      }
+      if (cronJob.repeat && isNaN(+cronJob.repeat)) {
+        const interval = import_cron_parser.default.parseExpression(cronJob.repeat, { currentDate });
+        const next = interval.next();
+        return next.getTime();
+      } else if (!isNaN(+cronJob.repeat)) {
+        const repeat = +cronJob.repeat;
+        const next = timestamp + repeat - (timestamp - startTime) % repeat;
+        return next;
+      } else {
+        return null;
+      }
+    } else {
+      if (startTime < timestamp) {
+        return null;
+      }
+      return timestamp;
+    }
+  }
+  schedule(cronJob, nextTime, toggle = true) {
+    if (toggle) {
+      const key = `${cronJob.id}@${nextTime}`;
+      if (!this.timers.has(key)) {
+        const interval = Math.max(nextTime - Date.now(), 0);
+        if (interval > MAX_SAFE_INTERVAL) {
+          this.timers.set(
+            key,
+            setTimeout(() => {
+              this.timers.delete(key);
+              this.schedule(cronJob, nextTime);
+            }, MAX_SAFE_INTERVAL)
+          );
+        } else {
+          this.timers.set(key, setTimeout(this.trigger.bind(this, cronJob.id, nextTime), interval));
+        }
+      }
+    } else {
+      for (const [key, timer] of this.timers.entries()) {
+        if (key.startsWith(`${cronJob.id}@`)) {
+          clearTimeout(timer);
+          this.timers.delete(key);
+        }
+      }
+    }
+  }
+  async trigger(cronJobId, time) {
+    try {
+      const cronJob = await this.db.getRepository(import_constants.COLLECTION_AUTOBACKUP).findOne({ filterByTk: cronJobId });
+      if (!cronJob) {
+        this.app.logger.warn(`Scheduled cron job ${cronJobId} no longer exists`);
+        const eventKey2 = `${cronJobId}@${time}`;
+        this.timers.delete(eventKey2);
+        return;
+      }
+      const eventKey = `${cronJob.id}@${time}`;
+      this.timers.delete(eventKey);
+      try {
+        const dumper = new import_dumper.Dumper(this.app);
+        const filename = await dumper.getLockFile(this.app.name);
+        this.app.worker.callPluginMethod({
+          plugin: _PluginBackupRestoreServer,
+          method: "workerCreateBackUp",
+          params: {
+            dataTypes: cronJob.dumpRules,
+            appName: this.app.name,
+            filename
+          },
+          // 目前限制方法并发为1
+          concurrency: 1
+        }).finally(() => {
+          dumper.cleanLockFile(filename, this.app.name);
+          const dirPath = dumper.backUpStorageDir(this.app.name);
+          (0, import_files.cleanOldFiles)(dumper.backUpStorageDir(this.app.name), cronJob.maxNumber).then(() => {
+            this.app.logger.info(`clean backup ${dirPath} to count: {cronJob.maxNumber}`);
+          }).catch((err) => {
+            this.app.logger.error("clean backup error", err);
+          });
+        });
+      } catch (e) {
+        this.app.logger.error(e);
+      }
+      const nextTime = this.getNextTime(cronJob, /* @__PURE__ */ new Date(), true);
+      if (nextTime) {
+        this.schedule(cronJob, nextTime);
+      }
+    } catch (e) {
+      this.app.logger.error(`cronJobs [${cronJobId}] failed: ${e.message}`);
+    }
+  }
+  on(cronJob) {
+    this.inspect([cronJob]);
+  }
+  off(cronJob) {
+    this.schedule(cronJob, null, false);
   }
   async workerCreateBackUp(data) {
     await new import_dumper.Dumper(this.app).runDumpTask({
@@ -50,4 +227,6 @@ class PluginBackupRestoreServer extends import_server.Plugin {
       fileName: data.filename
     });
   }
-}
+};
+_PluginBackupRestoreServer.inspectFields = ["repeat", "enabled"];
+let PluginBackupRestoreServer = _PluginBackupRestoreServer;

package/dist/server/utils/files.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 清理指定目录中旧的 .tbdump 文件，仅保留最新的 maxNumber 个文件
+ * @param dirPath 目标目录路径
+ * @param maxNumber 要保留的最新文件数量
+ */
+export declare function cleanOldFiles(dirPath: string, maxNumber: number): Promise<void>;

package/dist/server/utils/files.js

@@ -0,0 +1,59 @@
+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 files_exports = {};
+__export(files_exports, {
+  cleanOldFiles: () => cleanOldFiles
+});
+module.exports = __toCommonJS(files_exports);
+var import_promises = require("node:fs/promises");
+var import_path = __toESM(require("path"));
+async function cleanOldFiles(dirPath, maxNumber) {
+  const names = await (0, import_promises.readdir)(dirPath);
+  const files = await Promise.all(
+    names.map(async (name) => {
+      const filePath = import_path.default.join(dirPath, name);
+      try {
+        const info = await (0, import_promises.stat)(filePath);
+        if (info.isFile() && import_path.default.extname(name) === ".tbdump") {
+          return { name, mtime: info.mtime };
+        }
+      } catch (err) {
+        return null;
+      }
+      return null;
+    })
+  );
+  const validFiles = files.filter(Boolean);
+  validFiles.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  const toDelete = validFiles.slice(maxNumber).map((f) => f.name);
+  await Promise.all(toDelete.map((name) => (0, import_promises.unlink)(import_path.default.join(dirPath, name))));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cleanOldFiles
+});

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@tachybase/module-backup",
   "displayName": "App backup & restore",
-  "version": "1.0.18",
+  "version": "1.1.0",
   "description": "Backup and restore applications for scenarios such as application replication, migration, and upgrades.",
   "keywords": [
     "System management"
   ],
   "license": "Apache-2.0",
   "main": "./dist/server/index.js",
+  "dependencies": {
+    "cron-parser": "4.9.0",
+    "react-js-cron": "^3.2.0"
+  },
   "devDependencies": {
     "@ant-design/icons": "^5.5.2",
     "@hapi/topo": "^6.0.2",
@@ -30,16 +34,17 @@
     "semver": "^7.6.3",
     "tar": "^6.2.1",
     "yauzl": "^3.2.0",
-    "@tachybase/components": "1.0.18",
-    "@tachybase/module-worker-thread": "1.0.18"
+    "@tachybase/components": "1.1.0",
+    "@tachybase/module-worker-thread": "1.1.0"
   },
   "peerDependencies": {
-    "@tachybase/actions": "1.0.18",
-    "@tachybase/client": "1.0.18",
-    "@tachybase/database": "1.0.18",
-    "@tachybase/test": "1.0.18",
-    "@tachybase/utils": "1.0.18",
-    "@tachybase/server": "1.0.18"
+    "@tachybase/actions": "1.1.0",
+    "@tachybase/client": "1.1.0",
+    "@tachybase/database": "1.1.0",
+    "@tachybase/schema": "1.1.0",
+    "@tachybase/server": "1.1.0",
+    "@tachybase/test": "1.1.0",
+    "@tachybase/utils": "1.1.0"
   },
   "description.zh-CN": "备份和还原应用，可用于应用的复制、迁移、升级等场景。",
   "displayName.zh-CN": "应用的备份与还原",