@tachybase/module-backup 0.23.8

package/dist/node_modules/semver/ranges/simplify.js

@@ -0,0 +1,47 @@
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+module.exports = (versions, range, options) => {
+  const set = []
+  let first = null
+  let prev = null
+  const v = versions.sort((a, b) => compare(a, b, options))
+  for (const version of v) {
+    const included = satisfies(version, range, options)
+    if (included) {
+      prev = version
+      if (!first) {
+        first = version
+      }
+    } else {
+      if (prev) {
+        set.push([first, prev])
+      }
+      prev = null
+      first = null
+    }
+  }
+  if (first) {
+    set.push([first, null])
+  }
+
+  const ranges = []
+  for (const [min, max] of set) {
+    if (min === max) {
+      ranges.push(min)
+    } else if (!max && min === v[0]) {
+      ranges.push('*')
+    } else if (!max) {
+      ranges.push(`>=${min}`)
+    } else if (min === v[0]) {
+      ranges.push(`<=${max}`)
+    } else {
+      ranges.push(`${min} - ${max}`)
+    }
+  }
+  const simplified = ranges.join(' || ')
+  const original = typeof range.raw === 'string' ? range.raw : String(range)
+  return simplified.length < original.length ? simplified : range
+}

package/dist/node_modules/semver/ranges/subset.js

@@ -0,0 +1,247 @@
+const Range = require('../classes/range.js')
+const Comparator = require('../classes/comparator.js')
+const { ANY } = Comparator
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+
+// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
+// - Every simple range `r1, r2, ...` is a null set, OR
+// - Every simple range `r1, r2, ...` which is not a null set is a subset of
+//   some `R1, R2, ...`
+//
+// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
+// - If c is only the ANY comparator
+//   - If C is only the ANY comparator, return true
+//   - Else if in prerelease mode, return false
+//   - else replace c with `[>=0.0.0]`
+// - If C is only the ANY comparator
+//   - if in prerelease mode, return true
+//   - else replace C with `[>=0.0.0]`
+// - Let EQ be the set of = comparators in c
+// - If EQ is more than one, return true (null set)
+// - Let GT be the highest > or >= comparator in c
+// - Let LT be the lowest < or <= comparator in c
+// - If GT and LT, and GT.semver > LT.semver, return true (null set)
+// - If any C is a = range, and GT or LT are set, return false
+// - If EQ
+//   - If GT, and EQ does not satisfy GT, return true (null set)
+//   - If LT, and EQ does not satisfy LT, return true (null set)
+//   - If EQ satisfies every C, return true
+//   - Else return false
+// - If GT
+//   - If GT.semver is lower than any > or >= comp in C, return false
+//   - If GT is >=, and GT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the GT.semver tuple, return false
+// - If LT
+//   - If LT.semver is greater than any < or <= comp in C, return false
+//   - If LT is <=, and LT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the LT.semver tuple, return false
+// - Else return true
+
+const subset = (sub, dom, options = {}) => {
+  if (sub === dom) {
+    return true
+  }
+
+  sub = new Range(sub, options)
+  dom = new Range(dom, options)
+  let sawNonNull = false
+
+  OUTER: for (const simpleSub of sub.set) {
+    for (const simpleDom of dom.set) {
+      const isSub = simpleSubset(simpleSub, simpleDom, options)
+      sawNonNull = sawNonNull || isSub !== null
+      if (isSub) {
+        continue OUTER
+      }
+    }
+    // the null set is a subset of everything, but null simple ranges in
+    // a complex range should be ignored.  so if we saw a non-null range,
+    // then we know this isn't a subset, but if EVERY simple range was null,
+    // then it is a subset.
+    if (sawNonNull) {
+      return false
+    }
+  }
+  return true
+}
+
+const minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]
+const minimumVersion = [new Comparator('>=0.0.0')]
+
+const simpleSubset = (sub, dom, options) => {
+  if (sub === dom) {
+    return true
+  }
+
+  if (sub.length === 1 && sub[0].semver === ANY) {
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      return true
+    } else if (options.includePrerelease) {
+      sub = minimumVersionWithPreRelease
+    } else {
+      sub = minimumVersion
+    }
+  }
+
+  if (dom.length === 1 && dom[0].semver === ANY) {
+    if (options.includePrerelease) {
+      return true
+    } else {
+      dom = minimumVersion
+    }
+  }
+
+  const eqSet = new Set()
+  let gt, lt
+  for (const c of sub) {
+    if (c.operator === '>' || c.operator === '>=') {
+      gt = higherGT(gt, c, options)
+    } else if (c.operator === '<' || c.operator === '<=') {
+      lt = lowerLT(lt, c, options)
+    } else {
+      eqSet.add(c.semver)
+    }
+  }
+
+  if (eqSet.size > 1) {
+    return null
+  }
+
+  let gtltComp
+  if (gt && lt) {
+    gtltComp = compare(gt.semver, lt.semver, options)
+    if (gtltComp > 0) {
+      return null
+    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
+      return null
+    }
+  }
+
+  // will iterate one or zero times
+  for (const eq of eqSet) {
+    if (gt && !satisfies(eq, String(gt), options)) {
+      return null
+    }
+
+    if (lt && !satisfies(eq, String(lt), options)) {
+      return null
+    }
+
+    for (const c of dom) {
+      if (!satisfies(eq, String(c), options)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  let higher, lower
+  let hasDomLT, hasDomGT
+  // if the subset has a prerelease, we need a comparator in the superset
+  // with the same tuple and a prerelease, or it's not a subset
+  let needDomLTPre = lt &&
+    !options.includePrerelease &&
+    lt.semver.prerelease.length ? lt.semver : false
+  let needDomGTPre = gt &&
+    !options.includePrerelease &&
+    gt.semver.prerelease.length ? gt.semver : false
+  // exception: <1.2.3-0 is the same as <1.2.3
+  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
+      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
+    needDomLTPre = false
+  }
+
+  for (const c of dom) {
+    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='
+    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='
+    if (gt) {
+      if (needDomGTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomGTPre.major &&
+            c.semver.minor === needDomGTPre.minor &&
+            c.semver.patch === needDomGTPre.patch) {
+          needDomGTPre = false
+        }
+      }
+      if (c.operator === '>' || c.operator === '>=') {
+        higher = higherGT(gt, c, options)
+        if (higher === c && higher !== gt) {
+          return false
+        }
+      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (lt) {
+      if (needDomLTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomLTPre.major &&
+            c.semver.minor === needDomLTPre.minor &&
+            c.semver.patch === needDomLTPre.patch) {
+          needDomLTPre = false
+        }
+      }
+      if (c.operator === '<' || c.operator === '<=') {
+        lower = lowerLT(lt, c, options)
+        if (lower === c && lower !== lt) {
+          return false
+        }
+      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (!c.operator && (lt || gt) && gtltComp !== 0) {
+      return false
+    }
+  }
+
+  // if there was a < or >, and nothing in the dom, then must be false
+  // UNLESS it was limited by another range in the other direction.
+  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
+  if (gt && hasDomLT && !lt && gtltComp !== 0) {
+    return false
+  }
+
+  if (lt && hasDomGT && !gt && gtltComp !== 0) {
+    return false
+  }
+
+  // we needed a prerelease range in a specific tuple, but didn't get one
+  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
+  // because it includes prereleases in the 1.2.3 tuple
+  if (needDomGTPre || needDomLTPre) {
+    return false
+  }
+
+  return true
+}
+
+// >=1.2.3 is lower than >1.2.3
+const higherGT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp > 0 ? a
+    : comp < 0 ? b
+    : b.operator === '>' && a.operator === '>=' ? b
+    : a
+}
+
+// <=1.2.3 is higher than <1.2.3
+const lowerLT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp < 0 ? a
+    : comp > 0 ? b
+    : b.operator === '<' && a.operator === '<=' ? b
+    : a
+}
+
+module.exports = subset

package/dist/node_modules/semver/ranges/to-comparators.js

@@ -0,0 +1,8 @@
+const Range = require('../classes/range')
+
+// Mostly just for testing and legacy API reasons
+const toComparators = (range, options) =>
+  new Range(range, options).set
+    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))
+
+module.exports = toComparators

package/dist/node_modules/semver/ranges/valid.js

@@ -0,0 +1,11 @@
+const Range = require('../classes/range')
+const validRange = (range, options) => {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range(range, options).range || '*'
+  } catch (er) {
+    return null
+  }
+}
+module.exports = validRange

package/dist/server/app-migrator.d.ts

@@ -0,0 +1,16 @@
+import EventEmitter from 'events';
+import { Application } from '@tachybase/server';
+export type AppMigratorOptions = {
+    workDir?: string;
+};
+declare abstract class AppMigrator extends EventEmitter {
+    readonly workDir: string;
+    app: Application;
+    abstract direction: 'restore' | 'dump';
+    emitAsync: (event: string | symbol, ...args: any[]) => Promise<boolean>;
+    constructor(app: Application, options?: AppMigratorOptions);
+    tmpDir(): string;
+    rmDir(dir: string): Promise<void>;
+    clearWorkDir(): Promise<void>;
+}
+export { AppMigrator };

package/dist/server/app-migrator.js

@@ -0,0 +1,61 @@
+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 app_migrator_exports = {};
+__export(app_migrator_exports, {
+  AppMigrator: () => AppMigrator
+});
+module.exports = __toCommonJS(app_migrator_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_events = __toESM(require("events"));
+var import_promises = __toESM(require("fs/promises"));
+var os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_utils = require("@tachybase/utils");
+class AppMigrator extends import_events.default {
+  workDir;
+  app;
+  constructor(app, options) {
+    super();
+    this.app = app;
+    this.workDir = (options == null ? void 0 : options.workDir) || this.tmpDir();
+  }
+  tmpDir() {
+    return import_path.default.resolve(os.tmpdir(), `tachybase-${import_crypto.default.randomUUID()}`);
+  }
+  async rmDir(dir) {
+    await import_promises.default.rm(dir, { recursive: true, force: true });
+  }
+  async clearWorkDir() {
+    await this.rmDir(this.workDir);
+  }
+}
+(0, import_utils.applyMixins)(AppMigrator, [import_utils.AsyncEmitter]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppMigrator
+});

package/dist/server/collection-group-manager.d.ts

@@ -0,0 +1,4 @@
+import { CollectionGroup } from '@tachybase/database';
+export declare class CollectionGroupManager {
+    static collectionGroups: CollectionGroup[];
+}

package/dist/server/collection-group-manager.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 collection_group_manager_exports = {};
+__export(collection_group_manager_exports, {
+  CollectionGroupManager: () => CollectionGroupManager
+});
+module.exports = __toCommonJS(collection_group_manager_exports);
+class CollectionGroupManager {
+  static collectionGroups = [];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectionGroupManager
+});

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

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

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

@@ -0,0 +1,67 @@
+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 restore_command_exports = {};
+__export(restore_command_exports, {
+  default: () => addRestoreCommand
+});
+module.exports = __toCommonJS(restore_command_exports);
+var import_server = require("@tachybase/server");
+var import_restorer = require("../restorer");
+function addRestoreCommand(app) {
+  app.command("restore").ipc().argument("<string>", "restore file path").option("-a, --app <appName>", "sub app name if you want to restore into a sub app").option("-f, --force", "force restore").option(
+    "-g, --groups <groups>",
+    "groups to restore",
+    (value, previous) => {
+      return previous.concat([value]);
+    },
+    []
+  ).action(async (restoreFilePath, options) => {
+    if (!options.force) {
+      app.logger.warn("This action will overwrite your current data, please make sure you have a backup\u2757\uFE0F\u2757\uFE0F");
+      return;
+    }
+    let importApp = 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;
+      }
+      importApp = subApp;
+    }
+    const groups = new Set(options.groups);
+    groups.add("required");
+    const restorer = new import_restorer.Restorer(importApp, {
+      backUpFilePath: restoreFilePath
+    });
+    await restorer.restore({
+      groups
+    });
+    await app.upgrade();
+  });
+}

package/dist/server/dumper.d.ts

@@ -0,0 +1,71 @@
+import { DumpRulesGroupType } from '@tachybase/database';
+import { AppMigrator } from './app-migrator';
+type DumpOptions = {
+    groups: Set<DumpRulesGroupType>;
+    fileName?: string;
+};
+type BackUpStatusOk = {
+    name: string;
+    createdAt: Date;
+    fileSize: string;
+    status: 'ok';
+};
+type BackUpStatusDoing = {
+    name: string;
+    inProgress: true;
+    status: 'in_progress';
+};
+export declare class Dumper extends AppMigrator {
+    static dumpTasks: Map<string, Promise<any>>;
+    direction: "dump";
+    sqlContent: {
+        [key: string]: {
+            sql: string | string[];
+            group: DumpRulesGroupType;
+        };
+    };
+    static getTaskPromise(taskId: string): Promise<any> | undefined;
+    static getFileStatus(filePath: string): Promise<BackUpStatusOk | BackUpStatusDoing>;
+    static generateFileName(): string;
+    writeSQLContent(key: string, data: {
+        sql: string | string[];
+        group: DumpRulesGroupType;
+    }): void;
+    getSQLContent(key: string): {
+        sql: string | string[];
+        group: DumpRulesGroupType;
+    };
+    getCollectionsByDataTypes(groups: Set<DumpRulesGroupType>): Promise<string[]>;
+    dumpableCollections(): Promise<any[]>;
+    collectionsGroupByDataTypes(): Promise<{
+        [k: string]: any[];
+    }>;
+    backUpStorageDir(): string;
+    allBackUpFilePaths(options?: {
+        includeInProgress?: boolean;
+        dir?: string;
+    }): Promise<string[]>;
+    backUpFilePath(fileName: string): string;
+    lockFilePath(fileName: string): string;
+    writeLockFile(fileName: string): Promise<void>;
+    cleanLockFile(fileName: string): Promise<void>;
+    runDumpTask(options: Omit<DumpOptions, 'fileName'>): Promise<string>;
+    dumpableCollectionsGroupByGroup(): Promise<{
+        [x: string]: Pick<any, string>[];
+    }>;
+    dump(options: DumpOptions): Promise<{
+        filePath: string;
+        dirname: string;
+    }>;
+    dumpDb(options: DumpOptions): Promise<void>;
+    hasSqlContent(): boolean;
+    dumpMeta(additionalMeta?: object): Promise<void>;
+    dumpCollection(options: {
+        name: string;
+    }): Promise<void>;
+    packDumpedDir(fileName: string): Promise<{
+        filePath: string;
+        dirname: string;
+    }>;
+}
+export {};