@saltcorn/admin-models 1.6.3-beta.1 → 1.7.0-alpha.1

package/dist/models/pack.js

@@ -1,68 +1,33 @@
-"use strict";
 /**
  * Packs
  * @category saltcorn-admin-models
  * @module pack
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const table_1 = __importDefault(require("@saltcorn/data/models/table"));
-const index_1 = __importDefault(require("@saltcorn/data/db/index"));
-const view_1 = __importDefault(require("@saltcorn/data/models/view"));
-const field_1 = __importDefault(require("@saltcorn/data/models/field"));
-const trigger_1 = __importDefault(require("@saltcorn/data/models/trigger"));
-const workflow_step_1 = __importDefault(require("@saltcorn/data/models/workflow_step"));
-const { getState } = require("@saltcorn/data/db/state");
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const page_1 = __importDefault(require("@saltcorn/data/models/page"));
-const page_group_1 = __importDefault(require("@saltcorn/data/models/page_group"));
-const table_constraints_1 = __importDefault(require("@saltcorn/data/models/table_constraints"));
-const role_1 = __importDefault(require("@saltcorn/data/models/role"));
-const library_1 = __importDefault(require("@saltcorn/data/models/library"));
-const tag_1 = __importDefault(require("@saltcorn/data/models/tag"));
-const tag_entry_1 = __importDefault(require("@saltcorn/data/models/tag_entry"));
-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 user_1 = __importDefault(require("@saltcorn/data/models/user"));
-const config_1 = __importDefault(require("@saltcorn/data/models/config"));
-const { save_menu_items } = config_1.default;
-const lodash_1 = require("lodash");
-const { isStale, getFetchProxyOptions } = require("@saltcorn/data/utils");
+import Table from "@saltcorn/data/models/table";
+import db from "@saltcorn/data/db/index";
+import View from "@saltcorn/data/models/view";
+import Field from "@saltcorn/data/models/field";
+import Trigger from "@saltcorn/data/models/trigger";
+import WorkflowStep from "@saltcorn/data/models/workflow_step";
+import { getState } from "@saltcorn/data/db/state";
+import fetchLib from "node-fetch";
+const fetch = fetchLib; // NodeNext default-import interop for node-fetch
+import Page from "@saltcorn/data/models/page";
+import PageGroup from "@saltcorn/data/models/page_group";
+import TableConstraint from "@saltcorn/data/models/table_constraints";
+import Role from "@saltcorn/data/models/role";
+import Library from "@saltcorn/data/models/library";
+import Tag from "@saltcorn/data/models/tag";
+import TagEntry from "@saltcorn/data/models/tag_entry";
+import Model from "@saltcorn/data/models/model";
+import ModelInstance from "@saltcorn/data/models/model_instance";
+import EventLog from "@saltcorn/data/models/eventlog";
+import User from "@saltcorn/data/models/user";
+import * as config from "@saltcorn/data/models/config";
+const { save_menu_items } = config;
+import lodash from "lodash";
+const { isEqual } = lodash;
+import { isStale, getFetchProxyOptions } from "@saltcorn/data/utils";
 /**
  * Table Pack
  * @function
@@ -71,7 +36,7 @@ const { isStale, getFetchProxyOptions } = require("@saltcorn/data/utils");
 const table_pack = async (nameOrTable) => {
     // todo check this change
     const table = typeof nameOrTable === "string"
-        ? table_1.default.findOne({ name: nameOrTable })
+        ? Table.findOne({ name: nameOrTable })
         : nameOrTable;
     if (!table)
         throw new Error(`Unable to find table '${nameOrTable}'`);
@@ -82,7 +47,7 @@ const table_pack = async (nameOrTable) => {
         return o;
     };
     //const triggers = await Trigger.find({ table_id: table.id });
-    const constraints = await table_constraints_1.default.find({ table_id: table.id });
+    const constraints = await TableConstraint.find({ table_id: table.id });
     return {
         name: table.name,
         description: table.description,
@@ -94,6 +59,7 @@ const table_pack = async (nameOrTable) => {
         provider_name: table.provider_name,
         provider_cfg: table.provider_cfg,
         ownership_formula: table.ownership_formula,
+        rls_enabled: table.rls_enabled,
         fields: fields.map((f) => strip_ids(f.toJson)),
         //triggers: triggers.map((tr) => tr.toJson),
         constraints: constraints.map((c) => c.toJson),
@@ -107,10 +73,10 @@ const table_pack = async (nameOrTable) => {
  * @param name
  */
 const view_pack = async (name) => {
-    const view = typeof name === "string" ? await view_1.default.findOne({ name }) : name;
+    const view = typeof name === "string" ? await View.findOne({ name }) : name;
     if (!view)
         throw new Error(`Unable to find view '${name}'`);
-    const table = table_1.default.findOne({ id: view.table_id });
+    const table = Table.findOne({ id: view.table_id });
     //if (!table)
     //  throw new Error(`Unable to find table with id '${view.table_id}'`);
     return {
@@ -132,7 +98,7 @@ const view_pack = async (name) => {
  * @param name
  */
 const plugin_pack = async (name) => {
-    const Plugin = (await Promise.resolve().then(() => __importStar(require("@saltcorn/data/models/plugin")))).default;
+    const Plugin = (await import("@saltcorn/data/models/plugin")).default;
     const plugin = await Plugin.findOne({ name });
     if (!plugin)
         throw new Error(`Unable to find plugin '${name}'`);
@@ -160,7 +126,7 @@ const plugin_pack = async (name) => {
  * @param name name of the page
  */
 const page_pack = async (name) => {
-    const page = typeof name === "string" ? page_1.default.findOne({ name }) : name;
+    const page = typeof name === "string" ? Page.findOne({ name }) : name;
     if (!page)
         throw new Error(`Unable to find page '${name}'`);
     const root_page_for_roles = await page.is_root_page_for_roles();
@@ -181,7 +147,7 @@ const page_pack = async (name) => {
  * @param name name of the page group
  */
 const page_group_pack = async (name) => {
-    const group = page_group_1.default.findOne({ name });
+    const group = PageGroup.findOne({ name });
     if (!group)
         throw new Error(`Unable to find page group '${name}'`);
     return {
@@ -191,7 +157,7 @@ const page_group_pack = async (name) => {
         random_allocation: group.random_allocation,
         members: group.members.map((m) => {
             // could get slow (caching ?)
-            const page = page_1.default.findOne({ id: m.page_id });
+            const page = Page.findOne({ id: m.page_id });
             if (!page)
                 throw new Error(`Unable to find page '${m.page_id}'`);
             return {
@@ -209,7 +175,7 @@ const page_group_pack = async (name) => {
  * @param name
  */
 const library_pack = async (name) => {
-    const lib = await library_1.default.findOne({ name });
+    const lib = await Library.findOne({ name });
     return lib.toJson;
 };
 const orderWorkflowSteps = (steps) => {
@@ -318,10 +284,10 @@ const orderWorkflowSteps = (steps) => {
  * @param name
  */
 const trigger_pack = async (name) => {
-    const trig = typeof name === "string" ? await trigger_1.default.findOne({ name }) : name;
+    const trig = typeof name === "string" ? await Trigger.findOne({ name }) : name;
     const pack = trig.toJson;
     if (trig.action === "Workflow") {
-        const steps = await workflow_step_1.default.find({ trigger_id: trig.id });
+        const steps = await WorkflowStep.find({ trigger_id: trig.id });
         const ordered = orderWorkflowSteps(steps.map((s) => s.toJson));
         pack.steps = ordered;
     }
@@ -334,7 +300,7 @@ const trigger_pack = async (name) => {
  * @returns {Promise<object>}
  */
 const role_pack = async (role) => {
-    return await role_1.default.findOne({ role });
+    return await Role.findOne({ role });
 };
 /**
  * 'page/view/table/trigger' ids are replaced by names
@@ -342,32 +308,32 @@ const role_pack = async (role) => {
  * @returns
  */
 const tag_pack = async (name) => {
-    const tag = typeof name === "string" ? await tag_1.default.findOne({ name }) : name;
+    const tag = typeof name === "string" ? await Tag.findOne({ name }) : name;
     if (!tag)
         throw new Error(`Unable to find tag '${name}'`);
     const entries = await tag.getEntries();
     const withNames = entries.map((e) => {
         const result = {};
         if (e.page_id) {
-            const page = page_1.default.findOne({ id: e.page_id });
+            const page = Page.findOne({ id: e.page_id });
             if (!page)
                 throw new Error(`Unable to find page '${e.page_id}'`);
             result.page_name = page.name;
         }
         if (e.view_id) {
-            const view = view_1.default.findOne({ id: e.view_id });
+            const view = View.findOne({ id: e.view_id });
             if (!view)
                 throw new Error(`Unable to find view '${e.view_id}'`);
             result.view_name = view.name;
         }
         if (e.table_id) {
-            const table = table_1.default.findOne({ id: e.table_id });
+            const table = Table.findOne({ id: e.table_id });
             if (!table)
                 throw new Error(`Unable to find table '${e.table_id}'`);
             result.table_name = table.name;
         }
         if (e.trigger_id) {
-            const trigger = trigger_1.default.findOne({ id: e.trigger_id });
+            const trigger = Trigger.findOne({ id: e.trigger_id });
             if (!trigger)
                 throw new Error(`Unable to find trigger '${e.trigger_id}'`);
             result.trigger_name = trigger.name;
@@ -386,10 +352,10 @@ const tag_pack = async (name) => {
  * @returns
  */
 const model_pack = async (name, tableName) => {
-    const table = table_1.default.findOne({ name: tableName });
+    const table = Table.findOne({ name: tableName });
     if (!table)
         throw new Error(`Model-table '${tableName}' not found`);
-    const model = await model_1.default.findOne({ name, table_id: table.id });
+    const model = await Model.findOne({ name, table_id: table.id });
     if (!model)
         throw new Error(`Model '${name}' not found`);
     return model.toJson;
@@ -402,13 +368,13 @@ const model_pack = async (name, tableName) => {
  * @returns
  */
 const model_instance_pack = async (instanceName, modelName, tableName) => {
-    const table = table_1.default.findOne({ name: tableName });
+    const table = Table.findOne({ name: tableName });
     if (!table)
         throw new Error(`Model-table '${tableName}' not found`);
-    const model = await model_1.default.findOne({ name: modelName, table_id: table.id });
+    const model = await Model.findOne({ name: modelName, table_id: table.id });
     if (!model)
         throw new Error(`Unable to find model '${modelName}'`);
-    const instance = await model_instance_1.default.findOne({
+    const instance = await ModelInstance.findOne({
         name: instanceName,
         model_id: model.id,
     });
@@ -432,7 +398,7 @@ const event_log_pack = async (eventLog) => {
         const userId = result.user_id;
         if (result.user_id)
             delete result.user_id;
-        const user = await user_1.default.findOne({ id: userId });
+        const user = await User.findOne({ id: userId });
         if (user)
             result.user_email = user.email;
     }
@@ -444,16 +410,16 @@ const event_log_pack = async (eventLog) => {
  */
 const can_install_pack = async (pack) => {
     const warns = new Array();
-    const allViews = (await view_1.default.find()).map((t) => ({
+    const allViews = (await View.find()).map((t) => ({
         name: t.name,
-        table: table_1.default.findOne({ id: t.table_id })?.name,
+        table: Table.findOne({ id: t.table_id })?.name,
     }));
     for (const pt of pack.tables || []) {
-        const matchTable = table_1.default.findOne({ name: pt.name });
+        const matchTable = Table.findOne({ name: pt.name });
         if (!matchTable)
             continue;
         //failure conditions: existing field with different type (warn)
-        pt.fields.forEach((f) => {
+        (pt.fields || []).forEach((f) => {
             const ex = matchTable.getField(f.name);
             if (ex && ex.type_name !== f.type) {
                 warns.push(`Clashing field types for ${f.name} on table ${pt.name}`);
@@ -463,8 +429,8 @@ const can_install_pack = async (pack) => {
     const matchViews = allViews.filter((dbt) => (pack.views || []).some((pv) => pv.name === dbt.name && dbt.table && pv.table !== dbt.table));
     pack.tables.forEach((t) => {
         if (t.name === "users") {
-            const userTable = table_1.default.findOne({ name: "users" });
-            t.fields.forEach((f) => {
+            const userTable = Table.findOne({ name: "users" });
+            (t.fields || []).forEach((f) => {
                 if (f.required) {
                     const ex = userTable?.getField(f.name);
                     if (!ex || !ex.required)
@@ -488,22 +454,22 @@ const can_install_pack = async (pack) => {
  */
 const uninstall_pack = async (pack, name) => {
     for (const pageGroupSpec of pack.page_groups || []) {
-        const pageGroup = page_group_1.default.findOne({ name: pageGroupSpec.name });
+        const pageGroup = PageGroup.findOne({ name: pageGroupSpec.name });
         if (pageGroup)
             await pageGroup.delete();
     }
     for (const pageSpec of pack.pages || []) {
-        const page = page_1.default.findOne({ name: pageSpec.name });
+        const page = Page.findOne({ name: pageSpec.name });
         if (page)
             await page.delete();
     }
     for (const viewSpec of pack.views) {
-        const view = view_1.default.findOne({ name: viewSpec.name });
+        const view = View.findOne({ name: viewSpec.name });
         if (view)
             await view.delete();
     }
     for (const tableSpec of pack.tables) {
-        const table = table_1.default.findOne({ name: tableSpec.name });
+        const table = Table.findOne({ name: tableSpec.name });
         if (table && table.name === "users")
             continue;
         if (table) {
@@ -512,14 +478,14 @@ const uninstall_pack = async (pack, name) => {
                 if (field.is_fkey)
                     await field.delete();
             }
-            const triggers = trigger_1.default.find({ table_id: table.id });
+            const triggers = Trigger.find({ table_id: table.id });
             for (const trigger of triggers) {
                 await trigger.delete();
             }
         }
     }
     for (const tableSpec of pack.tables) {
-        const table = table_1.default.findOne({ name: tableSpec.name });
+        const table = Table.findOne({ name: tableSpec.name });
         if (table && table.name !== "users")
             await table.delete();
     }
@@ -594,8 +560,11 @@ const filter_pack = (pack, options) => {
  * @param loadAndSaveNewPlugin
  * @param bare_tables
  */
-const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = false) => {
-    const Plugin = (await Promise.resolve().then(() => __importStar(require("@saltcorn/data/models/plugin")))).default;
+const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = false, onLog) => {
+    const log = (msg) => onLog?.(msg);
+    const Plugin = (await import("@saltcorn/data/models/plugin")).default;
+    if (pack.plugins?.length)
+        log("Restoring plugins");
     for (const plugin of pack.plugins) {
         if (plugin.source === "npm" && plugin.name.startsWith("@saltcorn/"))
             plugin.name = plugin.name.replace("@saltcorn/", "");
@@ -611,31 +580,37 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
             }
         }
     }
+    if (pack.roles?.length)
+        log("Restoring roles");
     for (const role of pack.roles || []) {
         role.id = old_to_new_role(role.id);
-        const existing = await role_1.default.findOne({ id: role.id });
+        const existing = await Role.findOne({ id: role.id });
         if (existing)
             await existing.update(role);
         else
-            await role_1.default.create(role);
+            await Role.create(role);
     }
+    if (pack.library?.length)
+        log("Restoring library");
     for (const lib of pack.library || []) {
-        const exisiting = await library_1.default.findOne({ name: lib.name });
+        const exisiting = await Library.findOne({ name: lib.name });
         if (exisiting)
             await exisiting.update(lib);
         else
-            await library_1.default.create(lib);
+            await Library.create(lib);
     }
     // create tables (users skipped because created by other ways)
     // tables with a provider go last because they can depend on presence
     // of other tables
     const packTables = pack.tables.sort((left, right) => left.provider_name ? 1 : right.provider_name ? -1 : 0);
+    if (packTables.length)
+        log("Restoring table definitions");
     for (const tableSpec of packTables) {
         const { id, ownership_field_id, ownership_field_name, triggers, constraints, fields, ...updrow } = tableSpec;
         if (tableSpec.name !== "users") {
             let tbl_pk;
-            const existing = table_1.default.findOne({ name: tableSpec.name });
-            getState().log(5, `Restoring table pack name=${tableSpec.name} existing=${!!existing} tenant=${index_1.default.getTenantSchema()}`);
+            const existing = Table.findOne({ name: tableSpec.name });
+            getState().log(5, `Restoring table pack name=${tableSpec.name} existing=${!!existing} tenant=${db.getTenantSchema()}`);
             if (existing) {
                 tbl_pk = await existing.getField(existing.pk_name);
                 await existing.update(updrow);
@@ -643,34 +618,34 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
             else {
                 tableSpec.min_role_read = old_to_new_role(tableSpec.min_role_read);
                 tableSpec.min_role_write = old_to_new_role(tableSpec.min_role_write);
-                const table = await table_1.default.create(tableSpec.name, tableSpec);
+                const table = await Table.create(tableSpec.name, tableSpec);
                 [tbl_pk] = table.getFields();
             } //set pk
-            const pack_pk = tableSpec.fields.find((f) => f.primary_key);
+            const pack_pk = (tableSpec.fields || []).find((f) => f.primary_key);
             if (pack_pk && tbl_pk) {
                 await tbl_pk.update(pack_pk);
             }
         }
         else {
-            await user_1.default.table.update(updrow);
+            await User.table.update(updrow);
         }
     }
     await getState().refresh_tables(true);
     for (const tableSpec of pack.tables) {
-        const _table = table_1.default.findOne({ name: tableSpec.name });
+        const _table = Table.findOne({ name: tableSpec.name });
         if (!_table)
             throw new Error(`Unable to find table '${tableSpec.name}'`);
         const exfields = _table.getFields();
         if (!_table.provider_name)
-            for (const field of tableSpec.fields) {
+            for (const field of tableSpec.fields || []) {
                 const exfield = exfields.find((f) => f.name === field.name);
                 if (!((_table.name === "users" &&
                     (field.name === "email" || field.name === "role_id")) ||
                     exfield)) {
                     if (_table.name === "users" && field.required)
-                        await field_1.default.create({ table: _table, ...field, required: false }, bare_tables);
+                        await Field.create({ table: _table, ...field, required: false }, bare_tables);
                     else
-                        await field_1.default.create({ table: _table, ...field }, bare_tables);
+                        await Field.create({ table: _table, ...field }, bare_tables);
                 }
                 else if (exfield &&
                     !(_table.name === "users" &&
@@ -682,33 +657,40 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
             }
         for (const { table, ...trigger } of tableSpec.triggers || []) {
             trigger.min_role = old_to_new_role(trigger.min_role);
-            await trigger_1.default.create({ table: _table, ...trigger }); //legacy, not in new packs
+            await Trigger.create({ table: _table, ...trigger }); //legacy, not in new packs
         }
         const existing_constraints = _table.constraints;
         for (const constraint of tableSpec.constraints || []) {
             if (!existing_constraints.find((excon) => excon.type === constraint.type &&
-                (0, lodash_1.isEqual)(excon.configuration, constraint.configuration)))
-                await table_constraints_1.default.create({ table: _table, ...constraint });
+                isEqual(excon.configuration, constraint.configuration)))
+                await TableConstraint.create({ table: _table, ...constraint });
         }
         if (tableSpec.ownership_field_name) {
-            const owner_field = await field_1.default.findOne({
+            const owner_field = await Field.findOne({
                 table_id: _table.id,
                 name: tableSpec.ownership_field_name,
             });
             await _table.update({ ownership_field_id: owner_field.id });
         }
+        else if (tableSpec.rls_enabled && tableSpec.ownership_formula) {
+            const freshTable = Table.findOne({ name: _table.name });
+            if (freshTable)
+                await freshTable.enableOwnershipRLS();
+        }
     }
     await getState().refresh_tables(true);
+    if (pack.views?.length)
+        log("Restoring views");
     for (const viewSpec of pack.views) {
         viewSpec.min_role = old_to_new_role(viewSpec.min_role);
         const { table, on_menu, menu_label, on_root_page, ...viewNoTable } = viewSpec;
-        const vtable = table_1.default.findOne({ name: table });
-        const existing = view_1.default.findOne({ name: viewNoTable.name });
+        const vtable = Table.findOne({ name: table });
+        const existing = View.findOne({ name: viewNoTable.name });
         if (existing?.id) {
-            await view_1.default.update(viewNoTable, existing.id);
+            await View.update(viewNoTable, existing.id);
         }
         else {
-            await view_1.default.create({
+            await View.create({
                 ...viewNoTable,
                 table_id: vtable ? vtable.id : null,
             });
@@ -722,37 +704,41 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
             });
     }
     await getState().refresh_views(true);
+    if (pack.triggers?.length)
+        log("Restoring triggers");
     for (const triggerSpec of pack.triggers || []) {
         triggerSpec.min_role = old_to_new_role(triggerSpec.min_role);
         let id;
-        const existing = await trigger_1.default.findOne({ name: triggerSpec.name });
+        const existing = await Trigger.findOne({ name: triggerSpec.name });
         if (existing) {
             const { table_name, steps, ...tsNoTableName } = triggerSpec;
             if (table_name)
-                tsNoTableName.table_id = table_1.default.findOne({ name: table_name })?.id;
-            await trigger_1.default.update(existing.id, tsNoTableName);
+                tsNoTableName.table_id = Table.findOne({ name: table_name })?.id;
+            await Trigger.update(existing.id, tsNoTableName);
             id = existing.id;
         }
         else {
-            const newTrigger = await trigger_1.default.create(triggerSpec);
+            const newTrigger = await Trigger.create(triggerSpec);
             id = newTrigger.id;
         }
         if (triggerSpec.action === "Workflow" && triggerSpec.steps) {
-            await workflow_step_1.default.deleteForTrigger(id);
+            await WorkflowStep.deleteForTrigger(id);
             for (const step of triggerSpec.steps) {
-                await workflow_step_1.default.create({ ...step, trigger_id: id });
+                await WorkflowStep.create({ ...step, trigger_id: id });
             }
         }
     }
     await getState().refresh_triggers(true);
+    if (pack.pages?.length)
+        log("Restoring pages");
     for (const pageFullSpec of pack.pages || []) {
         pageFullSpec.min_role = old_to_new_role(pageFullSpec.min_role);
         const { root_page_for_roles, menu_label, ...pageSpec } = pageFullSpec;
-        const existing = page_1.default.findOne({ name: pageSpec.name });
+        const existing = Page.findOne({ name: pageSpec.name });
         if (existing?.id)
-            await page_1.default.update(existing.id, pageSpec);
+            await Page.update(existing.id, pageSpec);
         else
-            await page_1.default.create(pageSpec);
+            await Page.create(pageSpec);
         for (const role of root_page_for_roles || []) {
             const current_root = getState().getConfigCopy(role + "_home", "");
             if (!current_root || current_root === "")
@@ -767,51 +753,55 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
             });
     }
     await getState().refresh_pages(true);
+    if (pack.page_groups?.length)
+        log("Restoring page groups");
     for (const pageGroupSpec of pack.page_groups || []) {
         pageGroupSpec.min_role = old_to_new_role(pageGroupSpec.min_role);
         const { members, ...pageGroupNoMembers } = pageGroupSpec;
-        let existing = page_group_1.default.findOne({ name: pageGroupSpec.name });
+        let existing = PageGroup.findOne({ name: pageGroupSpec.name });
         if (existing?.id) {
             await existing.clearMembers(); // or merge ?
-            await page_group_1.default.update(existing.id, pageGroupNoMembers);
+            await PageGroup.update(existing.id, pageGroupNoMembers);
         }
         else
-            existing = await page_group_1.default.create(pageGroupNoMembers);
+            existing = await PageGroup.create(pageGroupNoMembers);
         const group = existing;
         if (!group)
             throw new Error(`Unable to create page group '${pageGroupSpec.name}'`);
         for (const member of members || []) {
             const { page_name, ...memberNoPageName } = member;
-            const page = page_1.default.findOne({ name: page_name });
+            const page = Page.findOne({ name: page_name });
             if (!page)
                 throw new Error(`Unable to find page '${member.page_name}'`);
             await group.addMember({ ...memberNoPageName, page_id: page.id });
         }
     }
+    if (pack.tags?.length)
+        log("Restoring tags");
     for (const tag of pack.tags || []) {
         const entries = tag.entries
             ? tag.entries.map((e) => {
                 const result = {};
                 if (e.page_name) {
-                    const page = page_1.default.findOne({ name: e.page_name });
+                    const page = Page.findOne({ name: e.page_name });
                     if (!page)
                         throw new Error(`Unable to find page '${e.page_name}'`);
                     result.page_id = page.id;
                 }
                 if (e.view_name) {
-                    const view = view_1.default.findOne({ name: e.view_name });
+                    const view = View.findOne({ name: e.view_name });
                     if (!view)
                         throw new Error(`Unable to find view '${e.view_name}'`);
                     result.view_id = view.id;
                 }
                 if (e.table_name) {
-                    const table = table_1.default.findOne({ name: e.table_name });
+                    const table = Table.findOne({ name: e.table_name });
                     if (!table)
                         throw new Error(`Unable to find table '${e.table_name}'`);
                     result.table_id = table.id;
                 }
                 if (e.trigger_name) {
-                    const trigger = trigger_1.default.findOne({ name: e.trigger_name });
+                    const trigger = Trigger.findOne({ name: e.trigger_name });
                     if (!trigger)
                         throw new Error(`Unable to find trigger '${e.trigger_name}'`);
                     result.trigger_id = trigger.id;
@@ -819,17 +809,19 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
                 return result;
             })
             : undefined;
-        const existing = await tag_1.default.findOne({ name: tag.name });
+        const existing = await Tag.findOne({ name: tag.name });
         if (!existing)
-            await tag_1.default.create({ name: tag.name, entries });
+            await Tag.create({ name: tag.name, entries });
         else {
             for (const entry of entries || []) {
-                await tag_entry_1.default.create({ tag_id: existing.id, ...entry });
+                await TagEntry.create({ tag_id: existing.id, ...entry });
             }
         }
     }
+    if (pack.models?.length)
+        log("Restoring models");
     for (const model of pack.models || []) {
-        const mTbl = table_1.default.findOne({ name: model.table_name });
+        const mTbl = Table.findOne({ name: model.table_name });
         if (!mTbl)
             throw new Error(`Unable to find table '${model.table_name}'`);
         if (!mTbl.id)
@@ -839,13 +831,13 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
             if (table_name === mTbl.name)
                 cfg.table_id = mTbl.id;
             else {
-                const cfgTbl = table_1.default.findOne({ name: table_name });
+                const cfgTbl = Table.findOne({ name: table_name });
                 if (!cfgTbl)
                     throw new Error(`Unable to find table '${table_name}'`);
                 cfg.table_id = cfgTbl.id;
             }
         }
-        const existing = await model_1.default.findOne({
+        const existing = await Model.findOne({
             name: model.name,
             table_id: mTbl.id,
         });
@@ -855,18 +847,20 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
                 configuration: cfg,
             });
         else
-            await model_1.default.create({
+            await Model.create({
                 name: model.name,
                 table_id: mTbl.id,
                 modelpattern: model.modelpattern,
                 configuration: cfg,
             });
     }
+    if (pack.model_instances?.length)
+        log("Restoring model instances");
     for (const modelInst of pack.model_instances || []) {
-        const table = table_1.default.findOne({ name: modelInst.table_name });
+        const table = Table.findOne({ name: modelInst.table_name });
         if (!table)
             throw new Error(`Unable to find table '${modelInst.table_name}'`);
-        const model = await model_1.default.findOne({
+        const model = await Model.findOne({
             name: modelInst.model_name,
             table_id: table.id,
         });
@@ -874,7 +868,7 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
             throw new Error(`Unable to find table '${modelInst.model_name}'`);
         const { model_name, ...mICfg } = modelInst;
         mICfg.model_id = model.id;
-        const existing = await model_instance_1.default.findOne({
+        const existing = await ModelInstance.findOne({
             name: modelInst.name,
             model_id: model.id,
         });
@@ -883,20 +877,22 @@ const install_pack = async (pack, name, loadAndSaveNewPlugin, bare_tables = fals
             await existing.update(updrow);
         }
         else
-            await model_instance_1.default.create(mICfg);
+            await ModelInstance.create(mICfg);
     }
+    if (pack.event_logs?.length)
+        log("Restoring event logs");
     for (const eventLog of pack.event_logs || []) {
         const { user_email, ...rest } = eventLog;
         const eventLogCfg = rest;
         if (user_email) {
-            const user = await user_1.default.findOne({ email: user_email });
+            const user = await User.findOne({ email: user_email });
             if (user)
                 eventLogCfg.user_id = user.id;
             else {
                 getState().log(3, `User '${user_email}' not found for event log ${eventLog.event_type}`);
             }
         }
-        await eventlog_1.default.create(eventLogCfg);
+        await EventLog.create(eventLogCfg);
     }
     if (pack.config) {
         const state = getState();
@@ -958,7 +954,7 @@ const fetch_available_packs_from_store = async () => {
     //const { getState } = require("../db/state");
     const packs_store_endpoint = getState().getConfig("packs_store_endpoint", false);
     //console.log(`[fetch_available_packs_from_store] packs_store_endpoint:%s`, packs_store_endpoint);
-    const response = await (0, node_fetch_1.default)(
+    const response = await fetch(
     //"http://store.saltcorn.com/api/packs?fields=name,description"
     packs_store_endpoint + "?fields=name,description", getFetchProxyOptions());
     const json = await response.json();
@@ -973,7 +969,7 @@ const fetch_pack_by_name = async (name) => {
     //const { getState } = require("../db/state");
     const packs_store_endpoint = getState().getConfig("packs_store_endpoint", false);
     //console.log(`[fetch_pack_by_name] packs_store_endpoint:%s`, packs_store_endpoint);
-    const response = await (0, node_fetch_1.default)(
+    const response = await fetch(
     //"http://store.saltcorn.com/api/packs?name=" + encodeURIComponent(name)
     packs_store_endpoint + "?name=" + encodeURIComponent(name), getFetchProxyOptions());
     const json = await response.json();
@@ -1026,7 +1022,7 @@ const create_pack_from_tag = async (tag) => {
     return pack;
     //TODO add models, plugins
 };
-module.exports = {
+export default {
     table_pack,
     view_pack,
     plugin_pack,