@tachybase/module-backup 0.23.8

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

@@ -0,0 +1,206 @@
+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_files_exports = {};
+__export(backup_files_exports, {
+  default: () => backup_files_default
+});
+module.exports = __toCommonJS(backup_files_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_os = __toESM(require("node:os"));
+var import_node_path = __toESM(require("node:path"));
+var import_actions = require("@tachybase/actions");
+var import_utils = require("@tachybase/utils");
+var import_dumper = require("../dumper");
+var import_restorer = require("../restorer");
+var import_server2 = __toESM(require("../server"));
+var backup_files_default = {
+  name: "backupFiles",
+  middleware: async (ctx, next) => {
+    if (ctx.action.actionName !== "upload") {
+      return next();
+    }
+    const storage = import_utils.koaMulter.diskStorage({
+      destination: import_node_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 { page = import_actions.DEFAULT_PAGE, pageSize = import_actions.DEFAULT_PER_PAGE } = ctx.action.params;
+      const dumper = new import_dumper.Dumper(ctx.app);
+      const backupFiles = await dumper.allBackUpFilePaths({
+        includeInProgress: true
+      });
+      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);
+        })
+      );
+      ctx.body = {
+        count,
+        rows,
+        page: Number(page),
+        pageSize: Number(pageSize),
+        totalPage: Math.ceil(count / pageSize)
+      };
+      await next();
+    },
+    async get(ctx, next) {
+      const { filterByTk } = ctx.action.params;
+      const dumper = new import_dumper.Dumper(ctx.app);
+      const filePath = dumper.backUpFilePath(filterByTk);
+      async function sendError(message, status = 404) {
+        ctx.body = { status: "error", message };
+        ctx.status = status;
+      }
+      try {
+        const fileState = await import_dumper.Dumper.getFileStatus(filePath);
+        if (fileState.status !== "ok") {
+          await sendError(`Backup file ${filterByTk} not found`);
+        } else {
+          const restorer = new import_restorer.Restorer(ctx.app, {
+            backUpFilePath: filePath
+          });
+          const restoreMeta = await restorer.parseBackupFile();
+          ctx.body = {
+            ...fileState,
+            meta: restoreMeta
+          };
+        }
+      } catch (e) {
+        if (e.code === "ENOENT") {
+          await sendError(`Backup file ${filterByTk} not found`);
+        }
+      }
+      await next();
+    },
+    /**
+     * create dump task
+     * @param ctx
+     * @param next
+     */
+    async create(ctx, next) {
+      var _a;
+      const data = ctx.request.body;
+      let taskId;
+      const app = ctx.app;
+      if ((_a = app.worker) == null ? void 0 : _a.available) {
+        taskId = await ctx.app.worker.callPluginMethod({
+          plugin: import_server2.default,
+          method: "workerCreateBackUp",
+          params: {
+            dataTypes: data.dataTypes
+          }
+        });
+        ctx.app.noticeManager.notify("backup", { msg: "done" });
+      } else {
+        const plugin = app.pm.get(import_server2.default);
+        taskId = await plugin.workerCreateBackUp(data);
+      }
+      ctx.body = {
+        key: taskId
+      };
+      await next();
+    },
+    /**
+     * download backup file
+     * @param ctx
+     * @param next
+     */
+    async download(ctx, next) {
+      const { filterByTk } = ctx.action.params;
+      const dumper = new import_dumper.Dumper(ctx.app);
+      const filePath = dumper.backUpFilePath(filterByTk);
+      const fileState = await import_dumper.Dumper.getFileStatus(filePath);
+      if (fileState.status !== "ok") {
+        throw new Error(`Backup file ${filterByTk} not found`);
+      }
+      ctx.attachment(filePath);
+      ctx.body = import_node_fs.default.createReadStream(filePath);
+      await next();
+    },
+    async restore(ctx, next) {
+      const { dataTypes, filterByTk, key } = ctx.action.params.values;
+      const filePath = (() => {
+        if (key) {
+          const tmpDir = import_node_os.default.tmpdir();
+          return import_node_path.default.resolve(tmpDir, key);
+        }
+        if (filterByTk) {
+          const dumper = new import_dumper.Dumper(ctx.app);
+          return dumper.backUpFilePath(filterByTk);
+        }
+      })();
+      if (!filePath) {
+        throw new Error(`Backup file ${filterByTk} not found`);
+      }
+      const args = ["restore", "-f", filePath];
+      for (const dataType of dataTypes) {
+        args.push("-g", dataType);
+      }
+      await ctx.app.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);
+      await import_promises.default.unlink(filePath);
+      ctx.body = {
+        status: "ok"
+      };
+      await next();
+    },
+    async upload(ctx, next) {
+      const file = ctx.file;
+      const fileName = file.filename;
+      const restorer = new import_restorer.Restorer(ctx.app, {
+        backUpFilePath: file.path
+      });
+      const restoreMeta = await restorer.parseBackupFile();
+      ctx.body = {
+        key: fileName,
+        meta: restoreMeta
+      };
+      await next();
+    },
+    async dumpableCollections(ctx, next) {
+      ctx.withoutDataWrapping = true;
+      const dumper = new import_dumper.Dumper(ctx.app);
+      ctx.body = await dumper.dumpableCollectionsGroupByGroup();
+      await next();
+    }
+  }
+};

package/dist/server/restorer.d.ts

@@ -0,0 +1,35 @@
+import { DumpRulesGroupType } from '@tachybase/database';
+import { Application } from '@tachybase/server';
+import { AppMigrator, AppMigratorOptions } from './app-migrator';
+type RestoreOptions = {
+    groups: Set<DumpRulesGroupType>;
+};
+export declare class Restorer extends AppMigrator {
+    direction: "restore";
+    backUpFilePath: string;
+    decompressed: boolean;
+    importedCollections: string[];
+    constructor(app: Application, options: AppMigratorOptions & {
+        backUpFilePath?: string;
+    });
+    static sortCollectionsByInherits(collections: Array<{
+        name: string;
+        inherits: string[];
+    }>): any;
+    setBackUpFilePath(backUpFilePath: string): void;
+    parseBackupFile(): Promise<any>;
+    restore(options: RestoreOptions): Promise<void>;
+    getImportMeta(): Promise<any>;
+    checkMeta(): Promise<void>;
+    importCollections(options: RestoreOptions): Promise<void>;
+    decompressBackup(backupFilePath: string): Promise<void>;
+    readCollectionMeta(collectionName: string): Promise<any>;
+    importCollection(options: {
+        name: string;
+        insert?: boolean;
+        clear?: boolean;
+        rowCondition?: (row: any) => boolean;
+    }): Promise<any>;
+    importDb(options: RestoreOptions): Promise<void>;
+}
+export {};

package/dist/server/restorer.js

@@ -0,0 +1,320 @@
+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 restorer_exports = {};
+__export(restorer_exports, {
+  Restorer: () => Restorer
+});
+module.exports = __toCommonJS(restorer_exports);
+var import_fs = __toESM(require("fs"));
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_database = require("@tachybase/database");
+var Topo = __toESM(require("@hapi/topo"));
+var import_decompress = __toESM(require("decompress"));
+var import_lodash = __toESM(require("lodash"));
+var import_semver = __toESM(require("semver"));
+var import_app_migrator = require("./app-migrator");
+var import_restore_check_error = require("./errors/restore-check-error");
+var import_field_value_writer = require("./field-value-writer");
+var import_utils = require("./utils");
+class Restorer extends import_app_migrator.AppMigrator {
+  direction = "restore";
+  backUpFilePath;
+  decompressed = false;
+  importedCollections = [];
+  constructor(app, options) {
+    super(app, options);
+    const { backUpFilePath } = options;
+    if (backUpFilePath) {
+      this.setBackUpFilePath(backUpFilePath);
+    }
+  }
+  static sortCollectionsByInherits(collections) {
+    var _a;
+    const sorter = new Topo.Sorter();
+    for (const collection of collections) {
+      const options = {
+        group: collection.name
+      };
+      if ((_a = collection.inherits) == null ? void 0 : _a.length) {
+        options.after = collection.inherits;
+      }
+      sorter.add(collection, options);
+    }
+    return sorter.sort();
+  }
+  setBackUpFilePath(backUpFilePath) {
+    if (import_path.default.isAbsolute(backUpFilePath)) {
+      this.backUpFilePath = backUpFilePath;
+    } else if (import_path.default.basename(backUpFilePath) === backUpFilePath) {
+      const dirname = import_path.default.resolve(process.cwd(), "storage", "duplicator");
+      this.backUpFilePath = import_path.default.resolve(dirname, backUpFilePath);
+    } else {
+      this.backUpFilePath = import_path.default.resolve(process.cwd(), backUpFilePath);
+    }
+  }
+  async parseBackupFile() {
+    await this.decompressBackup(this.backUpFilePath);
+    return await this.getImportMeta();
+  }
+  async restore(options) {
+    await this.decompressBackup(this.backUpFilePath);
+    await this.checkMeta();
+    await this.importCollections(options);
+    await this.importDb(options);
+    await this.clearWorkDir();
+  }
+  async getImportMeta() {
+    const metaFile = import_path.default.resolve(this.workDir, "meta");
+    return JSON.parse(await import_promises.default.readFile(metaFile, "utf8"));
+  }
+  async checkMeta() {
+    const meta = await this.getImportMeta();
+    if (!this.app.db.inDialect(meta["dialect"])) {
+      throw new import_restore_check_error.RestoreCheckError(`this backup file can only be imported in database ${meta["dialect"]}`);
+    }
+    const checkEnv = (envName) => {
+      const valueInPackage = meta[envName] || "";
+      const valueInEnv = process.env[envName] || "";
+      if (valueInPackage && valueInEnv !== valueInPackage) {
+        throw new import_restore_check_error.RestoreCheckError(`for use this backup file, please set ${envName}=${valueInPackage}`);
+      }
+    };
+    for (const envName of ["DB_UNDERSCORED", "DB_SCHEMA", "COLLECTION_MANAGER_SCHEMA", "DB_TABLE_PREFIX"]) {
+      checkEnv(envName);
+    }
+    const version = meta["version"];
+    if (import_semver.default.lt(version, "0.18.0-alpha.2")) {
+      throw new import_restore_check_error.RestoreCheckError(`this backup file can only be imported in tachybase ${version}`);
+    }
+  }
+  async importCollections(options) {
+    const importCollection = async (collectionName) => {
+      await this.importCollection({
+        name: collectionName
+      });
+    };
+    const { dumpableCollectionsGroupByGroup, delayCollections } = await this.parseBackupFile();
+    await importCollection("applicationPlugins");
+    await this.app.reload();
+    const metaCollections = dumpableCollectionsGroupByGroup.required;
+    for (const collection of metaCollections) {
+      if (collection.name === "applicationPlugins") {
+        continue;
+      }
+      if (delayCollections.includes(collection.name)) {
+        continue;
+      }
+      await importCollection(collection.name);
+    }
+    options.groups.delete("required");
+    const importGroups = [...options.groups];
+    for (const group of importGroups) {
+      const collections = dumpableCollectionsGroupByGroup[group];
+      if (!collections) {
+        this.app.logger.warn(`group ${group} not found`);
+        continue;
+      }
+      for (const collection of Restorer.sortCollectionsByInherits(collections)) {
+        await importCollection(collection.name);
+      }
+    }
+    await this.app.reload();
+    await this.app.db.getRepository("collections").load();
+    await this.app.db.sync();
+    for (const collectionName of delayCollections) {
+      const delayRestore = this.app.db.getCollection(collectionName).options.dumpRules["delayRestore"];
+      await delayRestore(this);
+    }
+    await this.emitAsync("restoreCollectionsFinished");
+  }
+  async decompressBackup(backupFilePath) {
+    if (!this.decompressed) await (0, import_decompress.default)(backupFilePath, this.workDir);
+  }
+  async readCollectionMeta(collectionName) {
+    const dir = this.workDir;
+    const collectionMetaPath = import_path.default.resolve(dir, "collections", collectionName, "meta");
+    const metaContent = await import_promises.default.readFile(collectionMetaPath, "utf8");
+    return JSON.parse(metaContent);
+  }
+  async importCollection(options) {
+    const app = this.app;
+    const db = app.db;
+    const collectionName = options.name;
+    if (!collectionName) {
+      throw new Error("collection name is required");
+    }
+    const dir = this.workDir;
+    const collectionDataPath = import_path.default.resolve(dir, "collections", collectionName, "data");
+    const collectionMetaPath = import_path.default.resolve(dir, "collections", collectionName, "meta");
+    try {
+      await import_promises.default.stat(collectionMetaPath);
+    } catch (e) {
+      app.logger.info(`${collectionName} has no meta`);
+      return;
+    }
+    const metaContent = await import_promises.default.readFile(collectionMetaPath, "utf8");
+    const meta = JSON.parse(metaContent);
+    let addSchemaTableName = meta.tableName;
+    if (!this.app.db.inDialect("postgres") && (0, import_lodash.isPlainObject)(addSchemaTableName)) {
+      addSchemaTableName = addSchemaTableName.tableName;
+    }
+    const columns = meta["columns"];
+    if (columns.length === 0) {
+      app.logger.info(`${collectionName} has no columns`);
+      return;
+    }
+    const fieldAttributes = import_lodash.default.mapValues(meta.attributes, (attr) => {
+      if (attr.isCollectionField) {
+        const fieldClass = db.fieldTypes.get(attr.type);
+        if (!fieldClass) throw new Error(`field type ${attr.type} not found`);
+        return new fieldClass(attr.typeOptions, {
+          database: db
+        });
+      }
+      return void 0;
+    });
+    const rawAttributes = import_lodash.default.mapValues(meta.attributes, (attr, key) => {
+      if (attr.isCollectionField) {
+        const field = fieldAttributes[key];
+        return {
+          ...field.toSequelize(),
+          field: attr.field
+        };
+      }
+      const DataTypeClass = import_database.DataTypes[db.options.dialect][attr.type] || import_database.DataTypes[attr.type];
+      const obj = {
+        ...attr,
+        type: new DataTypeClass()
+      };
+      if (attr.defaultValue && ["JSON", "JSONB", "JSONTYPE"].includes(attr.type)) {
+        obj.defaultValue = JSON.stringify(attr.defaultValue);
+      }
+      return obj;
+    });
+    if (options.clear !== false) {
+      await db.sequelize.getQueryInterface().dropTable(addSchemaTableName, {
+        cascade: true
+      });
+      await db.sequelize.getQueryInterface().createTable(addSchemaTableName, rawAttributes);
+      if (meta.inherits) {
+        for (const inherit of import_lodash.default.uniq(meta.inherits)) {
+          const parentMeta = await this.readCollectionMeta(inherit);
+          const sql2 = `ALTER TABLE ${app.db.utils.quoteTable(addSchemaTableName)} INHERIT ${app.db.utils.quoteTable(
+            parentMeta.tableName
+          )};`;
+          await db.sequelize.query(sql2);
+        }
+      }
+    }
+    const rows = await (0, import_utils.readLines)(collectionDataPath);
+    if (rows.length === 0) {
+      app.logger.info(`${collectionName} has no data to import`);
+      this.importedCollections.push(collectionName);
+      return;
+    }
+    const rowsWithMeta = rows.map(
+      (row) => JSON.parse(row).map((val, index) => [columns[index], val]).reduce((carry, [column, val]) => {
+        const field = fieldAttributes[column];
+        carry[column] = field ? import_field_value_writer.FieldValueWriter.write(field, val) : val;
+        return carry;
+      }, {})
+    ).filter((row) => {
+      if (options.rowCondition) {
+        return options.rowCondition(row);
+      }
+      return true;
+    });
+    if (rowsWithMeta.length === 0) {
+      app.logger.info(`${collectionName} has no data to import`);
+      this.importedCollections.push(collectionName);
+      return;
+    }
+    const insertGeneratorAttributes = import_lodash.default.mapKeys(rawAttributes, (value, key) => {
+      return value.field;
+    });
+    const sql = db.sequelize.queryInterface.queryGenerator.bulkInsertQuery(
+      addSchemaTableName,
+      rowsWithMeta,
+      {},
+      insertGeneratorAttributes
+    );
+    if (options.insert === false) {
+      return sql;
+    }
+    await app.db.sequelize.query(sql, {
+      type: "INSERT"
+    });
+    app.logger.info(`${collectionName} imported with ${rowsWithMeta.length} rows`);
+    if (meta.autoIncrement) {
+      const queryInterface = app.db.queryInterface;
+      await queryInterface.setAutoIncrementVal({
+        tableInfo: (0, import_lodash.isPlainObject)(meta.tableName) ? meta.tableName : {
+          schema: "public",
+          tableName: meta.tableName
+        },
+        columnName: meta.autoIncrement.fieldName,
+        seqName: meta.autoIncrement.seqName,
+        currentVal: meta.autoIncrement.currentVal
+      });
+    }
+    this.importedCollections.push(collectionName);
+  }
+  async importDb(options) {
+    const sqlContentPath = import_path.default.resolve(this.workDir, "sql-content.json");
+    if (!import_fs.default.existsSync(sqlContentPath)) {
+      return;
+    }
+    const sqlData = JSON.parse(await import_promises.default.readFile(sqlContentPath, "utf8"));
+    const sqlContent = Object.keys(sqlData).filter((key) => options.groups.has(sqlData[key].group)).reduce((acc, key) => {
+      acc[key] = sqlData[key];
+      return acc;
+    }, {});
+    const queries = Object.values(
+      sqlContent
+    );
+    for (const sqlData2 of queries) {
+      try {
+        this.app.logger.info(`import sql: ${sqlData2.sql}`);
+        for (const sql of import_lodash.default.castArray(sqlData2.sql)) {
+          await this.app.db.sequelize.query(sql);
+        }
+      } catch (e) {
+        if (e.name === "SequelizeDatabaseError") {
+          this.app.logger.error(e.message);
+        } else {
+          throw e;
+        }
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Restorer
+});

package/dist/server/server.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from '@tachybase/server';
+export default class PluginBackupRestoreServer extends Plugin {
+    beforeLoad(): void;
+    load(): Promise<void>;
+    workerCreateBackUp(data: {
+        dataTypes: string[];
+    }): Promise<string>;
+}

package/dist/server/server.js

@@ -0,0 +1,52 @@
+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 server_exports = {};
+__export(server_exports, {
+  default: () => PluginBackupRestoreServer
+});
+module.exports = __toCommonJS(server_exports);
+var import_server = require("@tachybase/server");
+var import_dumper = require("./dumper");
+var import_backup_files = __toESM(require("./resourcers/backup-files"));
+class PluginBackupRestoreServer extends import_server.Plugin {
+  beforeLoad() {
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}`,
+      actions: ["backupFiles:*"]
+    });
+  }
+  async load() {
+    this.app.resourcer.define(import_backup_files.default);
+  }
+  async workerCreateBackUp(data) {
+    const dumper = new import_dumper.Dumper(this.app);
+    return dumper.runDumpTask({
+      groups: new Set(data.dataTypes)
+    });
+  }
+}

package/dist/server/utils.d.ts

@@ -0,0 +1,5 @@
+import { Database } from '@tachybase/database';
+export declare const DUMPED_EXTENSION = "tbdump";
+export declare function sqlAdapter(database: Database, sql: string): string;
+export declare function readLines(filePath: string): Promise<any[]>;
+export declare function humanFileSize(bytes: any, si?: boolean, dp?: number): string;