@saltcorn/admin-models 1.6.0 → 1.7.0-alpha.0

package/dist/models/backup.js

@@ -1,88 +1,93 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const { getState } = require("@saltcorn/data/db/state");
-const index_1 = __importDefault(require("@saltcorn/data/db/index"));
-const table_1 = __importDefault(require("@saltcorn/data/models/table"));
-const common_types_1 = require("@saltcorn/types/common_types");
-const view_1 = __importDefault(require("@saltcorn/data/models/view"));
-const file_1 = __importDefault(require("@saltcorn/data/models/file"));
-const crash_1 = __importDefault(require("@saltcorn/data/models/crash"));
-const field_1 = __importDefault(require("@saltcorn/data/models/field"));
-const role_1 = __importDefault(require("@saltcorn/data/models/role"));
-const page_1 = __importDefault(require("@saltcorn/data/models/page"));
-const page_group_1 = __importDefault(require("@saltcorn/data/models/page_group"));
-const plugin_1 = __importDefault(require("@saltcorn/data/models/plugin"));
-const migrate_1 = require("@saltcorn/data/migrate");
-const adm_zip_1 = __importDefault(require("adm-zip"));
-const tmp_promise_1 = require("tmp-promise");
-const promises_1 = require("fs/promises");
-const fs_1 = require("fs");
-const path_1 = require("path");
-const dateformat_1 = __importDefault(require("dateformat"));
-const sync_1 = require("csv-stringify/sync");
-const csvtojson_1 = __importDefault(require("csvtojson"));
-const pack_1 = __importDefault(require("./pack"));
-const { table_pack, view_pack, plugin_pack, page_pack, page_group_pack, tag_pack, model_instance_pack, event_log_pack, install_pack, can_install_pack, trigger_pack, } = pack_1.default;
-const config_1 = __importDefault(require("@saltcorn/data/models/config"));
-const { configTypes } = config_1.default;
-const { asyncMap, isTest } = require("@saltcorn/data/utils");
-const trigger_1 = __importDefault(require("@saltcorn/data/models/trigger"));
-const library_1 = __importDefault(require("@saltcorn/data/models/library"));
-const tag_1 = __importDefault(require("@saltcorn/data/models/tag"));
-const model_1 = __importDefault(require("@saltcorn/data/models/model"));
-const model_instance_1 = __importDefault(require("@saltcorn/data/models/model_instance"));
-const eventlog_1 = __importDefault(require("@saltcorn/data/models/eventlog"));
-const path_2 = __importDefault(require("path"));
-const { exec, execSync, spawn } = require("child_process");
-const ssh2_sftp_client_1 = __importDefault(require("ssh2-sftp-client"));
-const os = require("os");
-const semver = require("semver");
-const client_s3_1 = require("@aws-sdk/client-s3");
-const lib_storage_1 = require("@aws-sdk/lib-storage");
-const metadata_1 = __importDefault(require("@saltcorn/data/models/metadata"));
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+import { getState } from "@saltcorn/data/db/state";
+import db from "@saltcorn/data/db/index";
+import Table from "@saltcorn/data/models/table";
+import { instanceOfErrorMsg } from "@saltcorn/types/common_types";
+import View from "@saltcorn/data/models/view";
+import File from "@saltcorn/data/models/file";
+import Crash from "@saltcorn/data/models/crash";
+import Field from "@saltcorn/data/models/field";
+import Role from "@saltcorn/data/models/role";
+import Page from "@saltcorn/data/models/page";
+import PageGroup from "@saltcorn/data/models/page_group";
+import Plugin from "@saltcorn/data/models/plugin";
+import { getMigrationsInDB } from "@saltcorn/data/migrate";
+import Zip from "adm-zip";
+import { dir } from "tmp-promise";
+import { writeFile, mkdir, copyFile, rename, readFile, unlink, readdir, stat, } from "fs/promises";
+import { existsSync, readdirSync, statSync, createReadStream } from "fs";
+import { join, basename } from "path";
+import dateFormatLib from "dateformat";
+const dateFormat = dateFormatLib; // NodeNext default-import interop for dateformat
+import { stringify } from "csv-stringify/sync";
+import csvtojson from "csvtojson";
+import pack from "./pack.js";
+const { table_pack, view_pack, plugin_pack, page_pack, page_group_pack, tag_pack, model_instance_pack, event_log_pack, install_pack, can_install_pack, trigger_pack, } = pack;
+import * as config from "@saltcorn/data/models/config";
+const { configTypes } = config;
+import { asyncMap, isTest } from "@saltcorn/data/utils";
+import Trigger from "@saltcorn/data/models/trigger";
+import Library from "@saltcorn/data/models/library";
+import Tag from "@saltcorn/data/models/tag";
+import Model from "@saltcorn/data/models/model";
+import ModelInstance from "@saltcorn/data/models/model_instance";
+import EventLog from "@saltcorn/data/models/eventlog";
+import path from "path";
+import { execSync, spawn } from "child_process";
+import SftpClient from "ssh2-sftp-client";
+import os from "os";
+import semver from "semver";
+// @aws-sdk is heavy to load (~50ms) and only used when backing up to S3,
+// so require it lazily rather than at module load time.
+let _awsS3;
+const awsS3 = () => _awsS3 || (_awsS3 = require("@aws-sdk/client-s3"));
+let _awsLibStorage;
+const awsLibStorage = () => _awsLibStorage || (_awsLibStorage = require("@aws-sdk/lib-storage"));
+import MetaData from "@saltcorn/data/models/metadata";
+import lodash from "lodash";
+const { orderBy } = lodash;
 /**
  * @param [withEventLog] - include event log
  */
 const create_pack_json = async (withEventLog = false, forSnapshot = false) => {
     const state = getState();
     // tables
-    const tables = await asyncMap(await table_1.default.find({}, { orderBy: "id" }), async (t) => await table_pack(t) // find already done before
+    const tables = await asyncMap(await Table.find({}, { orderBy: "id" }), async (t) => await table_pack(t) // find already done before
     );
     // views
-    const views = await asyncMap((await view_1.default.find({})).filter((v) => v.id), async (v) => await view_pack(v.name));
+    const views = await asyncMap((await View.find({})).filter((v) => v.id), async (v) => await view_pack(v.name));
     // plugins
-    const plugins = await asyncMap(await plugin_1.default.find({}, { orderBy: "id" }), async (v) => await plugin_pack(v.name));
+    const plugins = await asyncMap(await Plugin.find({}, { orderBy: "id" }), async (v) => await plugin_pack(v.name));
     // pages
-    const pages = await asyncMap(await page_1.default.find({}), async (v) => await page_pack(v.name));
+    const pages = await asyncMap(await Page.find({}), async (v) => await page_pack(v.name));
     // page groups
-    const page_groups = await asyncMap(await page_group_1.default.find({}), async (v) => await page_group_pack(v.name));
+    const page_groups = await asyncMap(await PageGroup.find({}), async (v) => await page_group_pack(v.name));
     // triggers
-    const triggers = await asyncMap(trigger_1.default.find({}), trigger_pack);
+    const triggers = await asyncMap(Trigger.find({}), trigger_pack);
     // roles
-    const roles = await role_1.default.find({});
+    const roles = await Role.find({});
     // library
-    const library = (await library_1.default.find({})).map((l) => l.toJson);
+    const library = (await Library.find({})).map((l) => l.toJson);
     // tags
-    const tags = await asyncMap(await tag_1.default.find({}), async (v) => await tag_pack(v.name));
+    const tags = await asyncMap(await Tag.find({}), async (v) => await tag_pack(v.name));
     // models
-    const models = (await model_1.default.find({})).map((m) => m.toJson);
+    const models = (await Model.find({})).map((m) => m.toJson);
     // model instances
     const model_instances = forSnapshot
         ? []
-        : await asyncMap(await model_instance_1.default.find({}), async (modelinst) => {
-            const model = await model_1.default.findOne({ id: modelinst.model_id });
+        : await asyncMap(await ModelInstance.find({}), async (modelinst) => {
+            const model = await Model.findOne({ id: modelinst.model_id });
             if (!model)
                 throw new Error(`Model of instance '${modelinst.name}' not found`);
-            const table = await table_1.default.findOne({ id: model.table_id });
+            const table = await Table.findOne({ id: model.table_id });
             if (!table)
                 throw new Error(`Table of model '${model.name}' not found`);
             return await model_instance_pack(modelinst.name, model.name, table.name);
         });
     // optional event log
     const event_logs = withEventLog
-        ? await asyncMap(await eventlog_1.default.find({}), async (e) => await event_log_pack(e))
+        ? await asyncMap(await EventLog.find({}), async (e) => await event_log_pack(e))
         : [];
     const function_code_pages = state.getConfigCopy("function_code_pages", {});
     const function_code_pages_tags = state.getConfigCopy("function_code_pages_tags", {});
@@ -110,7 +115,7 @@ const create_pack_json = async (withEventLog = false, forSnapshot = false) => {
         code_pages,
     };
     if (forSnapshot) {
-        const cfgs = await index_1.default.select("_sc_config");
+        const cfgs = await db.select("_sc_config");
         const config = {};
         for (const cfg of cfgs) {
             //exclude base url, multitenancy, ssl/lets encrypt,
@@ -118,7 +123,7 @@ const create_pack_json = async (withEventLog = false, forSnapshot = false) => {
                 continue;
             if (state.isFixedConfig(cfg.key))
                 continue;
-            config[cfg.key] = (index_1.default.isSQLite ? JSON.parse(cfg.value) : cfg.value)?.v;
+            config[cfg.key] = (db.isSQLite ? JSON.parse(cfg.value) : cfg.value)?.v;
         }
         pack.config = config;
     }
@@ -129,7 +134,7 @@ const create_pack_json = async (withEventLog = false, forSnapshot = false) => {
  */
 const create_pack = async (dirpath) => {
     const pack = await create_pack_json(getState().getConfig("backup_with_event_log", false));
-    await (0, promises_1.writeFile)((0, path_1.join)(dirpath, "pack.json"), JSON.stringify(pack));
+    await writeFile(join(dirpath, "pack.json"), JSON.stringify(pack));
 };
 /**
  *
@@ -139,13 +144,13 @@ const create_pack = async (dirpath) => {
 const create_csv_from_rows = async (rows, fnm) => {
     if (rows.length === 0)
         return;
-    const s = (0, sync_1.stringify)(rows, {
+    const s = stringify(rows, {
         header: true,
         cast: {
             date: (value) => value.toISOString(),
         },
     });
-    await (0, promises_1.writeFile)(fnm, s);
+    await writeFile(fnm, s);
 };
 const sanitiseTableName = (nm) => nm.replaceAll("/", "");
 /**
@@ -155,7 +160,7 @@ const sanitiseTableName = (nm) => nm.replaceAll("/", "");
  * @returns {Promise<void>}
  */
 const create_table_json = async (table, dirpath) => {
-    await table.dump_to_json((0, path_1.join)(dirpath, sanitiseTableName(table.name) + ".json"));
+    await table.dump_to_json(join(dirpath, sanitiseTableName(table.name) + ".json"));
 };
 /**
  * @function
@@ -163,15 +168,15 @@ const create_table_json = async (table, dirpath) => {
  * @return {Promise<void>}
  */
 const create_table_jsons = async (root_dirpath) => {
-    const dirpath = (0, path_1.join)(root_dirpath, "tables");
-    await (0, promises_1.mkdir)(dirpath, { recursive: true });
-    const tables = await table_1.default.find({});
+    const dirpath = join(root_dirpath, "tables");
+    await mkdir(dirpath, { recursive: true });
+    const tables = await Table.find({});
     const backup_history = getState().getConfig("backup_history", true);
     for (const t of tables) {
         if (!t.external && !t.provider_name) {
             await create_table_json(t, dirpath);
             if (t.versioned && backup_history) {
-                await t.dump_history_to_json((0, path_1.join)(dirpath, sanitiseTableName(t.name) + "__history.json"));
+                await t.dump_history_to_json(join(dirpath, sanitiseTableName(t.name) + "__history.json"));
             }
         }
     }
@@ -183,17 +188,17 @@ const create_table_jsons = async (root_dirpath) => {
  */
 const backup_files = async (root_dirpath) => {
     const backup_file_prefix = getState().getConfig("backup_file_prefix");
-    const dirpath = (0, path_1.join)(root_dirpath, "files");
-    await (0, promises_1.mkdir)(dirpath);
+    const dirpath = join(root_dirpath, "files");
+    await mkdir(dirpath);
     const allFiles = [];
     const iterFolder = async (folder) => {
-        const files = await file_1.default.find(folder ? { folder } : {});
+        const files = await File.find(folder ? { folder } : {});
         for (const f of files) {
-            const base = (0, path_1.basename)(f.location);
+            const base = basename(f.location);
             if (f.isDirectory && (await f.is_symlink()))
                 continue;
             else if (f.isDirectory && !(await f.is_symlink())) {
-                await (0, promises_1.mkdir)((0, path_1.join)(dirpath, f.path_to_serve));
+                await mkdir(join(dirpath, f.path_to_serve));
                 await iterFolder(f.path_to_serve);
             }
             else {
@@ -202,22 +207,22 @@ const backup_files = async (root_dirpath) => {
                     f.mime_sub === "zip" &&
                     !f.user_id)
                     continue;
-                await (0, promises_1.copyFile)(f.location, (0, path_1.join)(dirpath, folder || "", base));
+                await copyFile(f.location, join(dirpath, folder || "", base));
             }
-            f.location = path_2.default.join(folder || "", base);
+            f.location = path.join(folder || "", base);
             allFiles.push(f);
         }
     };
     await iterFolder();
-    await create_csv_from_rows(allFiles, (0, path_1.join)(root_dirpath, "files.csv"));
+    await create_csv_from_rows(allFiles, join(root_dirpath, "files.csv"));
 };
 const backup_migrations = async (root_dirpath) => {
-    const migrations = await (0, migrate_1.getMigrationsInDB)();
-    await (0, promises_1.writeFile)((0, path_1.join)(root_dirpath, "migrations.json"), JSON.stringify(migrations));
+    const migrations = await getMigrationsInDB();
+    await writeFile(join(root_dirpath, "migrations.json"), JSON.stringify(migrations));
 };
 const backup_metadata = async (root_dirpath) => {
-    const metadata = await metadata_1.default.find({});
-    await (0, promises_1.writeFile)((0, path_1.join)(root_dirpath, "metadata.json"), JSON.stringify(metadata));
+    const metadata = await MetaData.find({});
+    await writeFile(join(root_dirpath, "metadata.json"), JSON.stringify(metadata));
 };
 /**
  * @function
@@ -225,26 +230,26 @@ const backup_metadata = async (root_dirpath) => {
  * @returns {Promise<void>}
  */
 const backup_config = async (root_dirpath) => {
-    const dirpath = (0, path_1.join)(root_dirpath, "config");
-    await (0, promises_1.mkdir)(dirpath);
-    const cfgs = await index_1.default.select("_sc_config");
+    const dirpath = join(root_dirpath, "config");
+    await mkdir(dirpath);
+    const cfgs = await db.select("_sc_config");
     const state = getState();
     for (const cfg of cfgs) {
         if (!state.isFixedConfig(cfg.key))
-            await (0, promises_1.writeFile)((0, path_1.join)(dirpath, cfg.key), JSON.stringify(index_1.default.isSQLite ? JSON.parse(cfg.value) : cfg.value));
+            await writeFile(join(dirpath, cfg.key), JSON.stringify(db.isSQLite ? JSON.parse(cfg.value) : cfg.value));
     }
 };
 const backup_info_file = async (root_dirpath) => {
     const state = getState();
-    const migrations_run = await (0, migrate_1.getMigrationsInDB)();
-    const dbversion = await index_1.default.getVersion(true);
-    const saltcorn_version = index_1.default.connectObj.sc_version;
-    await (0, promises_1.writeFile)((0, path_1.join)(root_dirpath, "backup-info.json"), JSON.stringify({
+    const migrations_run = await getMigrationsInDB();
+    const dbversion = await db.getVersion(true);
+    const saltcorn_version = db.connectObj.sc_version;
+    await writeFile(join(root_dirpath, "backup-info.json"), JSON.stringify({
         saltcorn_version,
         migrations_run,
         backup_date: new Date().toISOString(),
         node_version: process.version,
-        database_type: index_1.default.isSQLite ? "SQLite" : "PostgreSQL",
+        database_type: db.isSQLite ? "SQLite" : "PostgreSQL",
         database_version: dbversion,
         os: {
             platform: os.platform(),
@@ -261,7 +266,7 @@ const zipFolder = async (folder, zipFileName) => {
     const backup_password = getState().getConfig("backup_password", "");
     if (backup_with_system_zip) {
         return await new Promise((resolve, reject) => {
-            const absZipPath = path_2.default.join(process.cwd(), zipFileName);
+            const absZipPath = path.join(process.cwd(), zipFileName);
             const args = [
                 "-5",
                 "-rq",
@@ -285,7 +290,7 @@ const zipFolder = async (folder, zipFileName) => {
         });
     }
     else {
-        const zip = new adm_zip_1.default();
+        const zip = new Zip();
         zip.addLocalFolder(folder);
         zip.writeZip(zipFileName);
     }
@@ -295,7 +300,7 @@ const zipFolder = async (folder, zipFileName) => {
  * @param fnm
  */
 const create_backup = async (fnm) => {
-    const tmpDir = await (0, tmp_promise_1.dir)({ unsafeCleanup: true });
+    const tmpDir = await dir({ unsafeCleanup: true });
     await create_pack(tmpDir.path);
     await create_table_jsons(tmpDir.path);
     await backup_files(tmpDir.path);
@@ -303,9 +308,9 @@ const create_backup = async (fnm) => {
     await backup_migrations(tmpDir.path);
     await backup_info_file(tmpDir.path);
     await backup_metadata(tmpDir.path);
-    const day = (0, dateformat_1.default)(new Date(), "yyyy-mm-dd-HH-MM");
-    const ten = index_1.default.getTenantSchema();
-    const tens = ten === index_1.default.connectObj.default_schema
+    const day = dateFormat(new Date(), "yyyy-mm-dd-HH-MM");
+    const ten = db.getTenantSchema();
+    const tens = ten === db.connectObj.default_schema
         ? getState().getConfig("site_name", "Saltcorn")
         : ten;
     const backup_file_prefix = getState().getConfig("backup_file_prefix");
@@ -338,7 +343,7 @@ const extract = async (fnm, dir, password) => {
         return await new Promise((resolve, reject) => {
             const args = [
                 ...(password ? [`-P${password}`] : []),
-                file_1.default.normalise(fnm),
+                File.normalise(fnm),
                 "-d",
                 dir,
             ];
@@ -362,7 +367,7 @@ const extract = async (fnm, dir, password) => {
         });
     }
     else {
-        const zip = new adm_zip_1.default(fnm);
+        const zip = new Zip(fnm);
         try {
             if (password) {
                 zip.extractAllTo(dir, true, false, password);
@@ -386,39 +391,39 @@ const extract = async (fnm, dir, password) => {
  * @returns {Promise<object>}
  */
 const restore_files = async (dirpath) => {
-    const fnm = (0, path_1.join)(dirpath, "files.csv");
+    const fnm = join(dirpath, "files.csv");
     const file_users = {};
     const newLocations = {};
     const state = getState();
-    if ((0, fs_1.existsSync)(fnm)) {
-        const file_rows = await (0, csvtojson_1.default)().fromFile(fnm);
+    if (existsSync(fnm)) {
+        const file_rows = await csvtojson().fromFile(fnm);
         for (const file of file_rows) {
             if (file.isDirectory)
-                await (0, promises_1.mkdir)(file_1.default.get_new_path(file.location), { recursive: true });
+                await mkdir(File.get_new_path(file.location), { recursive: true });
         }
         if (!isTest())
             state.log(2, `Restoring ${file_rows.length} files...`);
         for (const file of file_rows) {
             try {
-                const newPath = file_1.default.get_new_path(file.id ? file.filename : file.location);
+                const newPath = File.get_new_path(file.id ? file.filename : file.location);
                 //copy file
                 if (!file.isDirectory)
-                    await (0, promises_1.copyFile)((0, path_1.join)(dirpath, "files", file.location), newPath);
+                    await copyFile(join(dirpath, "files", file.location), newPath);
                 file_users[file.location] = file.user_id;
                 //set location
                 if (file.id)
                     newLocations[file.id] = file.id ? file.filename : file.location;
                 file.location = newPath;
                 //insert in db
-                await file_1.default.create(file);
+                await File.create(file);
                 //const id = await db.insert("_sc_files", file_row);}
             }
             catch (e) {
                 state.log(1, `Error restoring file ${JSON.stringify(file)}: ${e.message}`);
             }
         }
-        if (index_1.default.reset_sequence)
-            await index_1.default.reset_sequence("_sc_files");
+        if (db.reset_sequence)
+            await db.reset_sequence("_sc_files");
     }
     return { file_users, newLocations };
 };
@@ -427,10 +432,10 @@ const restore_files = async (dirpath) => {
  * @param newLocations
  */
 const correct_fileid_references_to_location = async (newLocations) => {
-    const fileFields = await field_1.default.find({ type: "File" });
+    const fileFields = await Field.find({ type: "File" });
     getState().log(2, `Correcting file id references to locations`);
     for (const field of fileFields) {
-        const table = table_1.default.findOne({ id: field.table_id });
+        const table = Table.findOne({ id: field.table_id });
         const rows = await table.getRows({});
         for (const row of rows) {
             if (row[field.name] && newLocations[row[field.name]]) {
@@ -449,7 +454,7 @@ const restore_file_users = async (file_users) => {
         getState().log(2, `Restoring file users`);
     for (const [id, user_id] of Object.entries(file_users)) {
         if (user_id) {
-            const file = await file_1.default.findOne(id);
+            const file = await File.findOne(id);
             if (file)
                 await file.set_user(user_id);
             //await db.update("_sc_files", { user_id }, id);
@@ -464,34 +469,34 @@ const restore_file_users = async (file_users) => {
  */
 const restore_tables = async (dirpath, restore_first_user) => {
     let err;
-    const tables = await table_1.default.find();
+    const tables = await Table.find();
     const restore_history = getState().getConfig("restore_history", true);
     for (const table of tables) {
         if (!isTest())
             getState().log(2, `restoring table ${table.name}`);
         const fnm_csv = table.name === "users"
-            ? (0, path_1.join)(dirpath, "users.csv")
-            : (0, path_1.join)(dirpath, "tables", sanitiseTableName(table.name) + ".csv");
-        const fnm_json = (0, path_1.join)(dirpath, "tables", sanitiseTableName(table.name) + ".json");
-        if ((0, fs_1.existsSync)(fnm_json)) {
+            ? join(dirpath, "users.csv")
+            : join(dirpath, "tables", sanitiseTableName(table.name) + ".csv");
+        const fnm_json = join(dirpath, "tables", sanitiseTableName(table.name) + ".json");
+        if (existsSync(fnm_json)) {
             const res = await table.import_json_file(fnm_json, table.name === "users" && !restore_first_user);
-            if ((0, common_types_1.instanceOfErrorMsg)(res)) {
+            if (instanceOfErrorMsg(res)) {
                 console.error(err);
                 err = (err || "") + res.error;
             }
         }
-        else if ((0, fs_1.existsSync)(fnm_csv)) {
+        else if (existsSync(fnm_csv)) {
             const res = await table.import_csv_file(fnm_csv, {
                 skip_first_data_row: table.name === "users" && !restore_first_user,
             });
-            if ((0, common_types_1.instanceOfErrorMsg)(res)) {
+            if (instanceOfErrorMsg(res)) {
                 console.error(res);
                 err = (err || "") + res.error;
             }
         }
         if (table.versioned && restore_history) {
-            const fnm_hist_json = (0, path_1.join)(dirpath, "tables", sanitiseTableName(table.name) + "__history.json");
-            if ((0, fs_1.existsSync)(fnm_hist_json)) {
+            const fnm_hist_json = join(dirpath, "tables", sanitiseTableName(table.name) + "__history.json");
+            if (existsSync(fnm_hist_json)) {
                 if (!isTest())
                     getState().log(2, `restoring table history ${table.name}`);
                 await table.import_json_history_file(fnm_hist_json);
@@ -515,22 +520,22 @@ const restore_tables = async (dirpath, restore_first_user) => {
  * @returns {Promise<void>}
  */
 const restore_config = async (dirpath) => {
-    const cfgs = (0, fs_1.readdirSync)((0, path_1.join)(dirpath, "config"));
+    const cfgs = readdirSync(join(dirpath, "config"));
     const state = getState();
     for (const cfg of cfgs) {
-        const s = await (0, promises_1.readFile)((0, path_1.join)(dirpath, "config", cfg));
+        const s = await readFile(join(dirpath, "config", cfg));
         await state.setConfig(cfg, JSON.parse(s.toString()).v);
     }
 };
 const restore_metadata = async (dirpath) => {
-    const fnm = (0, path_1.join)(dirpath, "metadata.json");
-    if (!(0, fs_1.existsSync)(fnm))
+    const fnm = join(dirpath, "metadata.json");
+    if (!existsSync(fnm))
         return;
     if (!isTest())
         getState().log(2, `Restoring metadata`);
-    const mds = JSON.parse((await (0, promises_1.readFile)(fnm)).toString());
+    const mds = JSON.parse((await readFile(fnm)).toString());
     for (const md of mds) {
-        await metadata_1.default.create(md);
+        await MetaData.create(md);
     }
 };
 /**
@@ -541,19 +546,19 @@ const restore_metadata = async (dirpath) => {
  */
 const restore = async (fnm, loadAndSaveNewPlugin, restore_first_user, password) => {
     const state = getState();
-    state.log(2, `Starting restore to tenant ${index_1.default.getTenantSchema()}`);
-    const tmpDir = await (0, tmp_promise_1.dir)({ unsafeCleanup: true });
+    state.log(2, `Starting restore to tenant ${db.getTenantSchema()}`);
+    const tmpDir = await dir({ unsafeCleanup: true });
     await extract(fnm, tmpDir.path, password);
     state.log(2, `Unzip done`);
     let basePath = tmpDir.path;
     // safari re-compressed. Safari unpacks zip files on download. If the user
     // chooses compress in finder, the backup dir is nested inside the zip file
-    if (!(0, fs_1.existsSync)((0, path_1.join)(basePath, "pack.json"))) {
-        const files = await (0, promises_1.readdir)(basePath);
+    if (!existsSync(join(basePath, "pack.json"))) {
+        const files = await readdir(basePath);
         let found = false;
         for (const file of files) {
-            if ((0, fs_1.existsSync)((0, path_1.join)(basePath, file, "pack.json"))) {
-                basePath = (0, path_1.join)(basePath, file);
+            if (existsSync(join(basePath, file, "pack.json"))) {
+                basePath = join(basePath, file);
                 found = true;
                 break;
             }
@@ -562,9 +567,9 @@ const restore = async (fnm, loadAndSaveNewPlugin, restore_first_user, password)
             return "Not a valid backup file";
     }
     let err;
-    if ((0, fs_1.existsSync)((0, path_1.join)(basePath, "backup-info.json"))) {
-        const info = JSON.parse((await (0, promises_1.readFile)((0, path_1.join)(basePath, "backup-info.json"))).toString());
-        const saltcorn_version = index_1.default.connectObj.sc_version;
+    if (existsSync(join(basePath, "backup-info.json"))) {
+        const info = JSON.parse((await readFile(join(basePath, "backup-info.json"))).toString());
+        const saltcorn_version = db.connectObj.sc_version;
         if (info.saltcorn_version &&
             semver.gt(info.saltcorn_version, saltcorn_version)) {
             err = `Warning: backup is from a more recent version (${info.saltcorn_version}) than the installed version (${saltcorn_version}). `;
@@ -573,7 +578,7 @@ const restore = async (fnm, loadAndSaveNewPlugin, restore_first_user, password)
     //install pack
     if (!isTest())
         state.log(2, `Reading pack`);
-    const pack = JSON.parse((await (0, promises_1.readFile)((0, path_1.join)(basePath, "pack.json"))).toString());
+    const pack = JSON.parse((await readFile(join(basePath, "pack.json"))).toString());
     const can_restore = await can_install_pack(pack);
     if (typeof can_restore !== "boolean" && can_restore.error) {
         return `Cannot restore backup, clashing entities: 
@@ -605,7 +610,7 @@ const restore = async (fnm, loadAndSaveNewPlugin, restore_first_user, password)
         await correct_fileid_references_to_location(newLocations);
     await restore_file_users(file_users);
     await tmpDir.cleanup();
-    state.log(2, `Completed restore to tenant ${index_1.default.getTenantSchema()}${err ? ` with errors ${err}` : " successfully"}`);
+    state.log(2, `Completed restore to tenant ${db.getTenantSchema()}${err ? ` with errors ${err}` : " successfully"}`);
     return err;
 };
 /**
@@ -619,18 +624,18 @@ const delete_old_backups = async () => {
     if (!expire_days || expire_days < 0)
         return;
     if (destination === "Local directory") {
-        const files = await (0, promises_1.readdir)(directory);
+        const files = await readdir(directory);
         for (const file of files) {
             if (!file.startsWith(backup_file_prefix))
                 continue;
-            const stats = await (0, promises_1.stat)(path_2.default.join(directory, file));
+            const stats = await stat(path.join(directory, file));
             const fileTime = stats.birthtime?.getTime
                 ? stats.birthtime.getTime()
                 : stats.mtime.getTime();
             const ageMs = new Date().getTime() - fileTime;
             const ageDays = ageMs / (1000 * 3600 * 24);
             if (ageDays > expire_days)
-                await (0, promises_1.unlink)(path_2.default.join(directory, file));
+                await unlink(path.join(directory, file));
         }
     }
     else if (destination === "S3") {
@@ -641,7 +646,7 @@ const delete_old_backups = async () => {
                 ? s3EndpointCfg
                 : `${s3Secure ? "https" : "http"}://${s3EndpointCfg}`
             : undefined;
-        const s3 = new client_s3_1.S3Client({
+        const s3 = new (awsS3().S3Client)({
             credentials: {
                 accessKeyId: getState().getConfig("backup_s3_access_key"),
                 secretAccessKey: getState().getConfig("backup_s3_access_secret"),
@@ -663,7 +668,7 @@ const delete_old_backups = async () => {
         try {
             let continuationToken = undefined;
             do {
-                const listedObjects = await s3.send(new client_s3_1.ListObjectsV2Command({
+                const listedObjects = await s3.send(new (awsS3().ListObjectsV2Command)({
                     ...listParams,
                     ContinuationToken: continuationToken,
                 }));
@@ -674,7 +679,10 @@ const delete_old_backups = async () => {
                         const ageMs = new Date().getTime() - new Date(obj.LastModified).getTime();
                         const ageDays = ageMs / (1000 * 3600 * 24);
                         if (ageDays > expire_days) {
-                            await s3.send(new client_s3_1.DeleteObjectCommand({ Bucket: bucket, Key: obj.Key }));
+                            await s3.send(new (awsS3().DeleteObjectCommand)({
+                                Bucket: bucket,
+                                Key: obj.Key,
+                            }));
                         }
                     }
                 }
@@ -703,12 +711,12 @@ const auto_backup_now_tenant = async (state) => {
     switch (destination) {
         case "Saltcorn files":
             if (directory.length > 0) {
-                await file_1.default.new_folder(directory);
+                await File.new_folder(directory);
             }
-            const newPath = file_1.default.get_new_path((0, path_1.join)(directory, fileName));
-            const stats = (0, fs_1.statSync)(fileName);
-            await (0, promises_1.copyFile)(fileName, newPath);
-            await file_1.default.create({
+            const newPath = File.get_new_path(join(directory, fileName));
+            const stats = statSync(fileName);
+            await copyFile(fileName, newPath);
+            await File.create({
                 filename: fileName,
                 location: newPath,
                 uploaded_at: new Date(),
@@ -717,35 +725,35 @@ const auto_backup_now_tenant = async (state) => {
                 mime_sub: "zip",
                 min_role_read: 1,
             });
-            await (0, promises_1.unlink)(fileName);
+            await unlink(fileName);
             break;
         case "Local directory":
             //const directory = state.getConfig("auto_backup_directory");
             if (directory.length > 0) {
-                await (0, promises_1.mkdir)(directory, { recursive: true });
+                await mkdir(directory, { recursive: true });
             }
-            await (0, promises_1.rename)(fileName, (0, path_1.join)(directory, fileName));
+            await rename(fileName, join(directory, fileName));
             await delete_old_backups();
             break;
         case "SFTP server":
-            let sftp = new ssh2_sftp_client_1.default();
+            let sftp = new SftpClient();
             await sftp.connect({
                 host: state.getConfig("auto_backup_server"),
                 port: state.getConfig("auto_backup_port"),
                 username: state.getConfig("auto_backup_username"),
                 password: state.getConfig("auto_backup_password"),
             });
-            let data = (0, fs_1.createReadStream)(fileName);
-            let remote = (0, path_1.join)(state.getConfig("auto_backup_directory", ""), (0, path_1.basename)(fileName));
+            let data = createReadStream(fileName);
+            let remote = join(state.getConfig("auto_backup_directory", ""), basename(fileName));
             const putres = await sftp.put(data, remote);
             state.log(6, `SFTP Put response: ${putres}`);
             await sftp.end();
             const retain_dir = state.getConfig("auto_backup_retain_local_directory");
             if (retain_dir) {
-                await (0, promises_1.mkdir)(retain_dir, { recursive: true });
-                await (0, promises_1.copyFile)(fileName, (0, path_1.join)(retain_dir, fileName));
+                await mkdir(retain_dir, { recursive: true });
+                await copyFile(fileName, join(retain_dir, fileName));
             }
-            await (0, promises_1.unlink)(fileName);
+            await unlink(fileName);
             break;
         case "S3":
             const bEndpointCfg = state.getConfig("backup_s3_endpoint");
@@ -755,7 +763,7 @@ const auto_backup_now_tenant = async (state) => {
                     ? bEndpointCfg
                     : `${bSecure ? "https" : "http"}://${bEndpointCfg}`
                 : undefined;
-            const s3 = new client_s3_1.S3({
+            const s3 = new (awsS3().S3)({
                 credentials: {
                     accessKeyId: state.getConfig("backup_s3_access_key"),
                     secretAccessKey: state.getConfig("backup_s3_access_secret"),
@@ -767,12 +775,12 @@ const auto_backup_now_tenant = async (state) => {
             const pathPrefix = (state.getConfig("backup_s3_path_prefix", "") || "")
                 .toString()
                 .replace(/^\/+|\/+$/g, "");
-            const s3Key = [pathPrefix, (0, path_1.basename)(fileName)]
+            const s3Key = [pathPrefix, basename(fileName)]
                 .filter((s) => s && s.length)
                 .join("/");
-            const fileStream = () => (0, fs_1.createReadStream)(fileName);
+            const fileStream = () => createReadStream(fileName);
             try {
-                const uploadResult = await new lib_storage_1.Upload({
+                const uploadResult = await new (awsLibStorage().Upload)({
                     client: s3,
                     params: {
                         Bucket: bucket,
@@ -797,14 +805,14 @@ const auto_backup_now_tenant = async (state) => {
     }
 };
 const auto_backup_now = async () => {
-    const isRoot = index_1.default.getTenantSchema() === index_1.default.connectObj.default_schema;
+    const isRoot = db.getTenantSchema() === db.connectObj.default_schema;
     const state = getState();
-    const tenantModule = require("./tenant");
+    const tenantModule = (await import("./tenant.js")).default;
     if (isRoot && state.getConfig("auto_backup_tenants"))
         await tenantModule.eachTenant(async () => {
             try {
                 await auto_backup_now_tenant(state);
-                await metadata_1.default.create({
+                await MetaData.create({
                     type: "Backup",
                     name: "Success",
                     body: {},
@@ -813,7 +821,7 @@ const auto_backup_now = async () => {
             }
             catch (e) {
                 console.error(e);
-                await crash_1.default.create(e, {
+                await Crash.create(e, {
                     url: `Scheduler auto backup for tenant`,
                     headers: {},
                 });
@@ -823,7 +831,7 @@ const auto_backup_now = async () => {
     else
         try {
             await auto_backup_now_tenant(state);
-            await metadata_1.default.create({
+            await MetaData.create({
                 type: "Backup",
                 name: "Success",
                 body: {},
@@ -832,14 +840,14 @@ const auto_backup_now = async () => {
         }
         catch (e) {
             console.error(e);
-            await crash_1.default.create(e, {
+            await Crash.create(e, {
                 url: `Scheduler auto backup`,
                 headers: {},
             });
             throw new Error(e);
         }
 };
-module.exports = {
+export default {
     create_backup,
     restore,
     create_csv_from_rows,