npm - @nocobase/plugin-backups - Versions diffs - 2.0.56 - Mend

@nocobase/plugin-backups 2.0.56

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (380) hide show

package/dist/node_modules/yauzl/index.js ADDED Viewed

@@ -0,0 +1 @@

package/dist/node_modules/yauzl/package.json ADDED Viewed

@@ -0,0 +1 @@

+ {"name":"yauzl","version":"3.3.0","description":"yet another unzip library for node","engines":{"node":">=12"},"main":"index.js","scripts":{"test":"node test/test.js"},"repository":{"type":"git","url":"git+https://github.com/thejoshwolfe/yauzl.git"},"keywords":["unzip","zip","stream","archive","file"],"author":"Josh Wolfe <thejoshwolfe@gmail.com>","license":"MIT","bugs":{"url":"https://github.com/thejoshwolfe/yauzl/issues"},"homepage":"https://github.com/thejoshwolfe/yauzl","dependencies":{"buffer-crc32":"~0.2.3","pend":"~1.2.0"},"devDependencies":{"bl":"^6.0.11"},"files":["fd-slicer.js","index.js"],"_lastModified":"2026-05-21T17:29:14.652Z"}

package/dist/server/adapters/database.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { DatabaseOptions } from '@nocobase/database';
+export interface DBAdapter {
+    dbOpts: DatabaseOptions;
+    backup(dir: string, skipFdw?: boolean): Promise<void>;
+    restore(filePath: string, schema?: string): Promise<void>;
+    check(op: 'backup' | 'restore'): Promise<void>;
+    clientVersion(op: 'backup' | 'restore'): Promise<string | void>;
+}
+export declare function getDBAdapter(dbOpts: DatabaseOptions): DBAdapter;

package/dist/server/adapters/database.js ADDED Viewed

@@ -0,0 +1,486 @@
+/**
+ * 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 database_exports = {};
+__export(database_exports, {
+  getDBAdapter: () => getDBAdapter
+});
+module.exports = __toCommonJS(database_exports);
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var fsPromises = __toESM(require("fs/promises"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_promises = require("stream/promises");
+var import_util = require("util");
+var import_utils = require("../utils");
+const exec = (0, import_util.promisify)(import_child_process.exec);
+const D$$ = import_os.default.platform() === "win32" ? "$$" : "\\$\\$";
+const STREAM_BUFFER_SIZE = 2 * 1024 * 1024;
+const run = async (command, envVars = {}) => {
+  try {
+    const { stdout } = await exec(command, { env: { ...process.env, ...envVars } });
+    return stdout;
+  } catch (error) {
+    throw new Error(`${error.message}`);
+  }
+};
+const formatPathInEnv = (path2) => {
+  if (path2 && /\s/.test(path2) && !/^".*"$/.test(path2) && !/^'.*'$/.test(path2)) {
+    return `"${path2}"`;
+  }
+  return path2;
+};
+const escapeStringLiteral = (value) => String(value).replace(/'/g, "''");
+class BaseDBAdapter {
+  constructor(dbOpts) {
+    this.dbOpts = dbOpts;
+  }
+  async check(_) {
+  }
+  async clientVersion(_) {
+  }
+  assertCommand = (command) => {
+    try {
+      (0, import_child_process.execSync)(`${command} --version`);
+    } catch (error) {
+      throw new Error(
+        `Command ${command} not found, please install it first. Check reference here: https://docs.nocobase.com/handbook/backups#installation`
+      );
+    }
+  };
+}
+class MySQLAdapter extends BaseDBAdapter {
+  #backupCmd = "mysqldump";
+  #restoreCmd = "mysql";
+  async check(op) {
+    switch (op) {
+      case "backup":
+        this.assertCommand(this.#backupCmd);
+        this.assertCommand(this.#restoreCmd);
+        break;
+      case "restore":
+        this.assertCommand(this.#restoreCmd);
+        break;
+    }
+  }
+  async clientVersion(op) {
+    const cmd = op === "backup" ? this.#backupCmd : this.#restoreCmd;
+    try {
+      return (0, import_child_process.execSync)(`${cmd} --version`).toString();
+    } catch (_error) {
+    }
+  }
+  async backup(dir, skipFdw = false) {
+    const { username, host, port, database, password } = this.dbOpts;
+    const filePath = `${dir}/data`;
+    const versionStr = await this.clientVersion("backup");
+    const versionMatch = (versionStr || "").match(/Ver\s+(\d+\.\d+\.\d+)/i);
+    const version = versionMatch ? Number(versionMatch[1].split(".")[0]) : null;
+    let createServerSQL = "";
+    if (!skipFdw) {
+      createServerSQL = await this.#getFederatedServerSQL(username, host, port, database, password);
+    }
+    const mysqldumpArgs = [
+      "-u",
+      username,
+      "-h",
+      host,
+      ...port ? ["-P", port.toString()] : [],
+      "--protocol=tcp",
+      "--hex-blob",
+      "--single-transaction",
+      "--skip-lock-tables",
+      "--set-gtid-purged=OFF",
+      "--routines",
+      "--triggers",
+      ...version && version > 7 ? ["--column-statistics=0"] : [],
+      database
+    ];
+    return new Promise((resolve, reject) => {
+      const mysqldumpProcess = (0, import_child_process.spawn)(this.#backupCmd, mysqldumpArgs, {
+        env: { ...process.env, MYSQL_PWD: password },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const writeStream = (0, import_fs.createWriteStream)(filePath, {
+        highWaterMark: STREAM_BUFFER_SIZE
+      });
+      const escapeTransform = new import_utils.EscapeQuoteTransform();
+      mysqldumpProcess.on("error", reject);
+      mysqldumpProcess.on("exit", (code) => {
+        if (code !== 0) {
+          reject(new Error(`mysqldump exited with code ${code}`));
+        }
+      });
+      writeStream.write("/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;\n");
+      writeStream.write("/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;\n");
+      writeStream.write("/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;\n");
+      writeStream.write("/*!40101 SET NAMES utf8mb4 */;\n\n");
+      if (createServerSQL) {
+        writeStream.write(`${createServerSQL}
+`);
+      }
+      (0, import_promises.pipeline)(
+        mysqldumpProcess.stdout,
+        escapeTransform,
+        writeStream
+      ).then(() => {
+        writeStream.write("\n/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;\n");
+        writeStream.write("/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;\n");
+        writeStream.write("/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;\n");
+        writeStream.end(() => resolve());
+      }).catch(reject);
+    });
+  }
+  async #getFederatedServerSQL(username, host, port, database, password) {
+    try {
+      const fetchFederatedTablesCommand = `mysql -u ${username} -h ${host} ${port ? `-P ${port}` : ""} --protocol=tcp -D ${database} -e "
+    SELECT TABLE_NAME
+    FROM information_schema.tables
+    WHERE table_schema = '${database}'
+      AND engine = 'FEDERATED';" -s -N`;
+      const federatedTables = (await run(fetchFederatedTablesCommand, { MYSQL_PWD: password })).trim();
+      if (!federatedTables) return "";
+      let servers = [];
+      if (federatedTables) {
+        const createTablePromises = federatedTables.split("\n").map(async (entry) => {
+          const createTableCommand = `mysql -u ${username} -h ${host} ${port ? `-P ${port}` : ""} --protocol=tcp -D ${database} -e "SHOW CREATE TABLE ${entry}" -s -N`;
+          const cmdRet = await run(createTableCommand, { MYSQL_PWD: password });
+          const match = cmdRet.match(/ENGINE=FEDERATED\s+.*CONNECTION\s*=\s*'([^']+)\/.*?'/i);
+          return match ? match[1] : "";
+        });
+        servers = await Promise.all(createTablePromises);
+      }
+      if (servers.filter((s) => s).length === 0) return "";
+      const fetchServerInfoCommand = `mysql -u ${username} -h ${host} ${port ? `-P ${port}` : ""} --protocol=tcp -D ${database} -e "
+    SELECT Server_name, Host, Db, Username, Password, Port FROM mysql.servers
+    WHERE Server_name IN ('${servers.filter((s) => s).join("','")}');" -s -N`;
+      const serverInfo = await run(fetchServerInfoCommand, { MYSQL_PWD: password });
+      if (!serverInfo) return "";
+      let createServerSQL = `
+        DELIMITER $$
+        DROP PROCEDURE IF EXISTS nocobase_create_server_if_not_exists$$
+        CREATE PROCEDURE nocobase_create_server_if_not_exists()
+        BEGIN
+      `;
+      const serverEntries = serverInfo.split("\n").filter((entry) => entry.trim() !== "");
+      serverEntries.forEach((entry) => {
+        const [Server_name, Host, Db, Username, Password, Port] = entry.split("	");
+        createServerSQL += `
+          IF NOT EXISTS (SELECT * FROM mysql.servers WHERE Server_name = '${Server_name}') THEN
+            CREATE SERVER ${Server_name} FOREIGN DATA WRAPPER mysql
+            OPTIONS (HOST '${Host}', DATABASE '${Db}', USER '${Username}', PASSWORD '${Password}', PORT ${Port});
+          END IF;
+        `;
+      });
+      createServerSQL += `
+        END$$
+        CALL nocobase_create_server_if_not_exists()$$
+        DELIMITER ;
+      `;
+      return createServerSQL;
+    } catch (error) {
+      return "";
+    }
+  }
+  async restore(filePath) {
+    const { username, host, port, database, password } = this.dbOpts;
+    const dropDataCommand = `mysql -u ${username} -h ${host} ${port ? `-P ${port}` : ""} --protocol=tcp -D ${database} -e "
+    DELIMITER $$
+    DROP PROCEDURE IF EXISTS drop_all_tables_and_triggers$$
+    CREATE PROCEDURE drop_all_tables_and_triggers()
+    BEGIN
+        DECLARE _done INT DEFAULT FALSE;
+        DECLARE _tableName VARCHAR(255);
+        DECLARE _triggerName VARCHAR(255);
+        -- Cursor for tables and views
+        DECLARE _cursor CURSOR FOR
+            SELECT table_name
+            FROM information_schema.TABLES
+            WHERE table_schema = SCHEMA();
+        -- Cursor for triggers
+        DECLARE _trigger_cursor CURSOR FOR
+            SELECT trigger_name
+            FROM information_schema.TRIGGERS
+            WHERE trigger_schema = SCHEMA();
+        -- Handler to continue if DROP statement fails
+        DECLARE CONTINUE HANDLER FOR SQLEXCEPTION SET _done = FALSE;
+        DECLARE CONTINUE HANDLER FOR NOT FOUND SET _done = TRUE;
+        -- Disable foreign key checks
+        SET FOREIGN_KEY_CHECKS = 0;
+        -- Open cursor to drop tables and views
+        OPEN _cursor;
+        REPEAT
+            FETCH _cursor INTO _tableName;
+            IF NOT _done THEN
+                SET @stmt_sql1 = CONCAT('DROP TABLE IF EXISTS ', _tableName);
+                SET @stmt_sql2 = CONCAT('DROP VIEW IF EXISTS ', _tableName);
+                PREPARE stmt1 FROM @stmt_sql1;
+                PREPARE stmt2 FROM @stmt_sql2;
+                EXECUTE stmt1;
+                EXECUTE stmt2;
+                DEALLOCATE PREPARE stmt1;
+                DEALLOCATE PREPARE stmt2;
+            END IF;
+        UNTIL _done END REPEAT;
+        CLOSE _cursor;
+        -- Reset _done for trigger deletion
+        SET _done = FALSE;
+        -- Open cursor to drop triggers
+        OPEN _trigger_cursor;
+        REPEAT
+            FETCH _trigger_cursor INTO _triggerName;
+            IF NOT _done THEN
+                SET @stmt_sql3 = CONCAT('DROP TRIGGER IF EXISTS ', _triggerName);
+                PREPARE stmt3 FROM @stmt_sql3;
+                EXECUTE stmt3;
+                DEALLOCATE PREPARE stmt3;
+            END IF;
+        UNTIL _done END REPEAT;
+        CLOSE _trigger_cursor;
+        -- Enable foreign key checks again
+        SET FOREIGN_KEY_CHECKS = 1;
+    END$$
+    CALL drop_all_tables_and_triggers()$$
+    DROP PROCEDURE drop_all_tables_and_triggers$$
+    DELIMITER ;
+    "`;
+    await run(dropDataCommand, { MYSQL_PWD: password });
+    const command = `${this.#restoreCmd} -u ${username} -h ${host} ${port ? `-P ${port}` : ""} --protocol=tcp ${database} < ${filePath}`;
+    await run(command, { MYSQL_PWD: password });
+  }
+}
+class PostgresAdapter extends BaseDBAdapter {
+  get #backupCmd() {
+    return formatPathInEnv(process.env.PG_DUMP_PATH) || "pg_dump";
+  }
+  get #restoreCmd() {
+    return formatPathInEnv(process.env.PG_RESTORE_PATH) || "pg_restore";
+  }
+  async check(op) {
+    switch (op) {
+      case "backup":
+        this.assertCommand(this.#backupCmd);
+        break;
+      case "restore":
+        this.assertCommand(this.#restoreCmd);
+        break;
+    }
+  }
+  async clientVersion(op) {
+    const cmd = op === "backup" ? this.#backupCmd : this.#restoreCmd;
+    try {
+      return (0, import_child_process.execSync)(`${cmd} --version`).toString();
+    } catch (_error) {
+    }
+  }
+  async backup(dir) {
+    const { username, host, port, database, password, schema: backupSchema } = this.dbOpts;
+    const filePath = `${dir}/data`;
+    const schemaOption = backupSchema ? `--schema=${backupSchema}` : "";
+    const command = `${this.#backupCmd} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -F c -b --quote-all-identifiers ${schemaOption} -f ${filePath} ${database}`;
+    await run(command, { PGPASSWORD: password });
+  }
+  async restore(filePath, schema) {
+    const { username, host, port, database, password } = this.dbOpts;
+    let schemaOption = this.dbOpts.schema;
+    if (schema && !schemaOption) {
+      schemaOption = "public";
+    }
+    const cpuCores = import_os.default.cpus().length;
+    const j = Math.max(1, Math.floor(cpuCores / 2));
+    const schemaNameCondition = schemaOption ? `WHERE schemaname = '${schemaOption}'` : `WHERE schemaname NOT IN ('pg_catalog', 'information_schema')`;
+    const relnamespaceCondition = schemaOption ? `WHERE relnamespace = '${schemaOption}'::regnamespace` : `WHERE tgrelid IN (SELECT oid FROM pg_class WHERE relnamespace NOT IN (SELECT oid FROM pg_catalog.pg_namespace WHERE nspname IN ('pg_catalog', 'information_schema')))`;
+    const dropDataCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
+    DO ${D$$} DECLARE r RECORD;
+    BEGIN
+    FOR r IN (SELECT viewname,schemaname FROM pg_views ${schemaNameCondition}) LOOP
+        BEGIN
+          EXECUTE 'DROP VIEW IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.tablename) || ' CASCADE';
+        EXCEPTION
+          WHEN OTHERS THEN
+        END;
+    END LOOP;
+    FOR r IN (SELECT tablename,schemaname FROM pg_tables ${schemaNameCondition}) LOOP
+      BEGIN
+        EXECUTE 'DROP TABLE IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.tablename) || ' CASCADE';
+      EXCEPTION
+        WHEN OTHERS THEN
+      END;
+    END LOOP;
+    FOR r IN (SELECT sequencename,schemaname FROM pg_sequences ${schemaNameCondition}) LOOP
+      BEGIN
+        EXECUTE 'DROP SEQUENCE IF EXISTS ' || quote_ident(r.schemaname) || '.' || quote_ident(r.tablename) || ' CASCADE';
+      EXCEPTION
+        WHEN OTHERS THEN
+      END;
+    END LOOP;
+    FOR r IN (
+      SELECT tgname, tgrelid::regclass::text AS table_fullname
+      FROM pg_trigger
+      WHERE tgrelid IN (SELECT oid FROM pg_class ${relnamespaceCondition})
+    ) LOOP
+      BEGIN
+        EXECUTE 'DROP TRIGGER IF EXISTS ' || quote_ident(r.tgname) || ' ON ' || quote_ident(r.table_fullname) || ' CASCADE';
+      EXCEPTION
+        WHEN OTHERS THEN
+      END;
+    END LOOP;
+    END ${D$$};"`.replace(/\n/g, " ");
+    await run(dropDataCommand, { PGPASSWORD: password });
+    if (schema === schemaOption || !schemaOption) {
+      const pgRestoreCommand = `${this.#restoreCmd} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} --clean --if-exists --no-owner -j ${j} ${filePath}`;
+      await run(pgRestoreCommand, { PGPASSWORD: password });
+    } else {
+      const srcSchema = schema || "public";
+      const pgRestoreCommand = `${this.#restoreCmd} -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -n ${srcSchema} -d ${database} --clean --if-exists --no-owner -j ${j} ${filePath}`;
+      await this.#restoreSchema(srcSchema, schemaOption, pgRestoreCommand);
+    }
+  }
+  async #restoreSchema(srcSchema, targetSchema, pgRestoreCommand) {
+    const { username, host, port, database, password } = this.dbOpts;
+    const ts = Date.now();
+    const preCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
+    DO ${D$$}
+    BEGIN
+        IF EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = '${srcSchema}') THEN
+            EXECUTE 'ALTER SCHEMA ${srcSchema} RENAME TO ${srcSchema}_${ts}';
+        END IF;
+        EXECUTE 'CREATE SCHEMA ${srcSchema}';
+    END ${D$$};"`.replace(/\n/g, " ");
+    const postCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
+    DO ${D$$}
+    BEGIN
+        EXECUTE 'DROP SCHEMA ${targetSchema} CASCADE';
+        EXECUTE 'ALTER SCHEMA ${srcSchema} RENAME TO ${targetSchema}';
+        IF EXISTS (SELECT 1 FROM information_schema.schemata WHERE schema_name = '${srcSchema}_${ts}') THEN
+            EXECUTE 'ALTER SCHEMA ${srcSchema}_${ts} RENAME TO ${srcSchema}';
+        END IF;
+    END ${D$$};"`.replace(/\n/g, " ");
+    await run(preCommand, { PGPASSWORD: password });
+    try {
+      await run(pgRestoreCommand, { PGPASSWORD: password });
+    } finally {
+      await run(postCommand, { PGPASSWORD: password });
+    }
+    await this.#syncCollectionSchemaMetadata(srcSchema, targetSchema);
+  }
+  async #syncCollectionSchemaMetadata(srcSchema, targetSchema) {
+    const { username, host, port, database, password, tablePrefix } = this.dbOpts;
+    const collectionsTable = `${tablePrefix || ""}collections`;
+    const targetSchemaLiteral = escapeStringLiteral(targetSchema);
+    const srcSchemaLiteral = escapeStringLiteral(srcSchema);
+    const collectionsTableLiteral = escapeStringLiteral(collectionsTable);
+    const updateCollectionSchemaCommand = `psql -U ${username} -h ${host} ${port ? `-p ${port}` : ""} -d ${database} -c "
+    DO ${D$$}
+    DECLARE
+        collections_table text := '${collectionsTableLiteral}';
+    BEGIN
+        IF EXISTS (
+            SELECT 1 FROM information_schema.columns
+            WHERE table_schema = '${targetSchemaLiteral}'
+              AND table_name = collections_table
+              AND column_name = 'options'
+        ) THEN
+            EXECUTE format(
+              'UPDATE %I.%I SET options = jsonb_set(options::jsonb, ''{schema}'', to_jsonb(%L::text), true) WHERE options->>''schema'' = %L',
+              '${targetSchemaLiteral}',
+              collections_table,
+              '${targetSchemaLiteral}',
+              '${srcSchemaLiteral}'
+            );
+        END IF;
+    END ${D$$};"`.replace(/\n/g, " ");
+    await run(updateCollectionSchemaCommand, { PGPASSWORD: password });
+  }
+}
+class SQLiteAdapter extends BaseDBAdapter {
+  async backup(dir) {
+    const { storage } = this.dbOpts;
+    const filePath = `${dir}/data`;
+    const dbFilePath = import_path.default.resolve(storage);
+    await fsPromises.copyFile(dbFilePath, filePath);
+  }
+  async restore(filePath) {
+    const { storage } = this.dbOpts;
+    const dbFilePath = import_path.default.resolve(storage);
+    await fsPromises.copyFile(filePath, dbFilePath, fsPromises.constants.COPYFILE_FICLONE);
+  }
+}
+class MariaDBAdapter extends MySQLAdapter {
+}
+const adapterMap = {
+  mysql: MySQLAdapter,
+  postgres: PostgresAdapter,
+  sqlite: SQLiteAdapter,
+  mariadb: MariaDBAdapter
+};
+function getDBAdapter(dbOpts) {
+  const Adapter = adapterMap[dbOpts.dialect];
+  if (!Adapter) {
+    throw new Error(`Unsupported database type ${dbOpts.dialect}`);
+  }
+  return new Adapter(dbOpts);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDBAdapter
+});

package/dist/server/collections/backup-settings.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ declare const _default: import("@nocobase/database").CollectionOptions;
2	+ export default _default;

package/dist/server/collections/backup-settings.js ADDED Viewed

@@ -0,0 +1,67 @@
+/**
+ * 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 __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 backup_settings_exports = {};
+__export(backup_settings_exports, {
+  default: () => backup_settings_default
+});
+module.exports = __toCommonJS(backup_settings_exports);
+var import_database = require("@nocobase/database");
+var import_utils = require("../utils");
+var backup_settings_default = (0, import_database.defineCollection)({
+  name: `${import_utils.SETTINGS}`,
+  dumpRules: "required",
+  migrationRules: ["overwrite", "skip"],
+  fields: [
+    {
+      type: "boolean",
+      name: "scheduled"
+    },
+    {
+      type: "string",
+      name: "cron"
+    },
+    {
+      type: "integer",
+      name: "keep"
+    },
+    {
+      type: "boolean",
+      name: "enableFilesBackup"
+    },
+    {
+      type: "belongsTo",
+      name: "storage",
+      target: "storages",
+      targetKey: "id",
+      foreignKey: "storageId"
+    },
+    {
+      type: "string",
+      name: "encryptionPassword"
+    }
+  ]
+});

package/dist/server/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { default } from './plugin';