@saltcorn/data 0.6.1-beta.1 → 0.6.2-beta.0

package/base-plugin/viewtemplates/viewable_fields.js

@@ -16,7 +16,7 @@ const { traverseSync } = require("../../models/layout");
 const { structuredClone } = require("../../utils");
 const db = require("../../db");
 
-/** 
+/**
  * @function
  * @param {string} viewname
  * @param {Table|object} table
@@ -42,8 +42,8 @@ const action_url = contract(
 );
 
 /**
- * @param {string} url 
- * @param {object} req 
+ * @param {string} url
+ * @param {object} req
  * @param {object} opts
  * @param {string} opts.action_name
  * @param {string} opts.action_label
@@ -55,7 +55,7 @@ const action_url = contract(
  * @param {string} opts.action_bgcol
  * @param {string} opts.action_bordercol
  * @param {string} opts.action_textcol
- * @param {*} __ 
+ * @param {*} __
  * @returns {object}
  */
 const action_link = (
@@ -174,7 +174,7 @@ const make_link = contract(
 );
 
 /**
- * @param {string} s 
+ * @param {string} s
  * @returns {object}
  */
 const parse_view_select = (s) => {
@@ -197,7 +197,7 @@ const parse_view_select = (s) => {
 };
 
 //todo: use above to simplify code
-/** 
+/**
  * @function
  * @param {object} opts
  * @param {string} opts.view,
@@ -338,7 +338,7 @@ const view_linker = contract(
 );
 
 /**
- * @param {string} nm 
+ * @param {string} nm
  * @returns {boolean}
  */
 const action_requires_write = (nm) => {
@@ -347,7 +347,7 @@ const action_requires_write = (nm) => {
   if (nm.startsWith("Toggle")) return true;
 };
 
-/** 
+/**
  * @function
  * @param {string} viewname
  * @param {Table|object} table
@@ -527,8 +527,8 @@ const get_viewable_fields = contract(
 );
 
 /**
- * @param {string} fname 
- * @param {object} req 
+ * @param {string} fname
+ * @param {object} req
  * @returns {string}
  */
 const sortlinkForName = (fname, req) => {
@@ -543,10 +543,10 @@ const sortlinkForName = (fname, req) => {
 };
 
 /**
- * @param {object} column 
- * @param {object} f 
- * @param {object} req 
- * @param {*} __ 
+ * @param {object} column
+ * @param {object} f
+ * @param {object} req
+ * @param {*} __
  * @returns {string}
  */
 const headerLabelForName = (column, f, req, __) => {
@@ -563,7 +563,7 @@ const headerLabelForName = (column, f, req, __) => {
   return label + arrow;
 };
 
-/** 
+/**
  * @function
  * @param {Field[]} fields
  * @param {object} state
@@ -597,12 +597,12 @@ const splitUniques = contract(
 );
 
 /**
- * @param {object} table 
- * @param {string} viewname 
- * @param {object[]} [columns] 
- * @param {object} layout0 
- * @param {boolean} id 
- * @param {object} req 
+ * @param {object} table
+ * @param {string} viewname
+ * @param {object[]} [columns]
+ * @param {object} layout0
+ * @param {boolean} id
+ * @param {object} req
  * @returns {Promise<Form>}
  */
 const getForm = async (table, viewname, columns, layout0, id, req) => {
@@ -626,7 +626,7 @@ const getForm = async (table, viewname, columns, layout0, id, req) => {
           }
           if (f.calculated)
             f.sourceURL = `/field/show-calculated/${table.name}/${f.name}/${f.fieldview}`;
-
+          f.attributes = { ...column.configuration, ...f.attributes };
           return f;
         } else if (table.name === "users" && column.field_name === "password") {
           return new Field({
@@ -669,15 +669,14 @@ const getForm = async (table, viewname, columns, layout0, id, req) => {
     fields: tfields,
     layout,
   });
-  await form.fill_fkey_options();
   if (id) form.hidden("id");
   return form;
 };
 
 /**
- * @param {object} table 
- * @param {object} req 
- * @param {object} fixed 
+ * @param {object} table
+ * @param {object} req
+ * @param {object} fixed
  * @returns {Promise<object>}
  */
 const fill_presets = async (table, req, fixed) => {

package/db/db.test.js

@@ -1,162 +1,8 @@
-const { sqlsanitize, mkWhere, sqlsanitizeAllowDots } = require("./internal");
 const db = require("./index.js");
 const Table = require("../models/table");
 
 afterAll(db.close);
 
-describe("sqlsanitize", () => {
-  it("should not alter valid name", () => {
-    expect(sqlsanitize("ffoo_oo")).toBe("ffoo_oo");
-  });
-  it("should remove spaces", () => {
-    expect(sqlsanitize(" ")).toBe("");
-  });
-  it("should remove chars from invalid name", () => {
-    expect(sqlsanitize("ffoo--oo--uu")).toBe("ffoooouu");
-  });
-  it("should not allow dots", () => {
-    expect(sqlsanitize("ffoo.oo")).toBe("ffoooo");
-  });
-  it("should allow dots when specified", () => {
-    expect(sqlsanitizeAllowDots("ffoo.oo")).toBe("ffoo.oo");
-  });
-  it("should allow quotes when dots specified", () => {
-    expect(sqlsanitizeAllowDots('ffoo."oo"')).toBe('ffoo."oo"');
-  });
-  it("should allow numbers", () => {
-    expect(sqlsanitize("ff1oo_oo")).toBe("ff1oo_oo");
-  });
-  it("should not allow numbers in initial position", () => {
-    expect(sqlsanitize("1ffoo_o1o")).toBe("_1ffoo_o1o");
-  });
-});
-
-describe("mkWhere", () => {
-  it("should empty on no arg", () => {
-    expect(mkWhere()).toStrictEqual({ values: [], where: "" });
-  });
-  it("should empty on null obj arg", () => {
-    expect(mkWhere({})).toStrictEqual({ values: [], where: "" });
-  });
-  it("should query json", () => {
-    expect(mkWhere({ foo: { json: ["bar", 5] } })).toStrictEqual({
-      values: [5],
-      where: `where "foo"->>'bar'=$1`,
-    });
-  });
-
-  it("should set id", () => {
-    expect(mkWhere({ id: 5 })).toStrictEqual({
-      values: [5],
-      where: 'where "id"=$1',
-    });
-    expect(mkWhere({ id: 5, hello: "world" })).toStrictEqual({
-      values: [5, "world"],
-      where: 'where "id"=$1 and "hello"=$2',
-    });
-  });
-  it("should query null", () => {
-    expect(mkWhere({ id: null })).toStrictEqual({
-      values: [],
-      where: 'where "id" is null',
-    });
-    expect(mkWhere({ id: null, foo: 1 })).toStrictEqual({
-      values: [1],
-      where: 'where "id" is null and "foo"=$1',
-    });
-    expect(mkWhere({ foo: 1, id: null })).toStrictEqual({
-      values: [1],
-      where: 'where "foo"=$1 and "id" is null',
-    });
-  });
-  it("should query lt/gt", () => {
-    expect(mkWhere({ id: { lt: 5 } })).toStrictEqual({
-      values: [5],
-      where: 'where "id"<$1',
-    });
-    expect(mkWhere({ id: { gt: 8 } })).toStrictEqual({
-      values: [8],
-      where: 'where "id">$1',
-    });
-    expect(mkWhere({ id: { lt: 5, equal: true } })).toStrictEqual({
-      values: [5],
-      where: 'where "id"<=$1',
-    });
-    expect(mkWhere({ id: { gt: 8, equal: true } })).toStrictEqual({
-      values: [8],
-      where: 'where "id">=$1',
-    });
-    expect(mkWhere({ id: [{ gt: 0 }, { lt: 10 }] })).toStrictEqual({
-      values: [0, 10],
-      where: 'where "id">$1 and "id"<$2',
-    });
-    expect(mkWhere({ id: { or: [{ gt: 10 }, { lt: 5 }] } })).toStrictEqual({
-      values: [10, 5],
-      where: 'where ("id">$1 or "id"<$2)',
-    });
-  });
-  it("should query subselect", () => {
-    expect(
-      mkWhere({
-        id: [{ inSelect: { table: "foo", field: "bar", where: { baz: 7 } } }],
-      })
-    ).toStrictEqual({
-      values: [7],
-      where: 'where "id" in (select bar from foo where "baz"=$1)',
-    });
-    expect(
-      mkWhere({
-        age: 45,
-        id: [{ inSelect: { table: "foo", field: "bar", where: { baz: 7 } } }],
-        name: "Alice",
-      })
-    ).toStrictEqual({
-      values: [45, 7, "Alice"],
-      where: `where "age"=$1 and "id" in (select bar from foo where "baz"=$2) and "name"=$3`,
-    });
-  });
-  it("should query or", () => {
-    expect(mkWhere({ or: [{ id: 5 }, { x: 7 }] })).toStrictEqual({
-      values: [5, 7],
-      where: 'where ("id"=$1 or "x"=$2)',
-    });
-    expect(mkWhere({ or: [{ id: 5 }, { x: { gt: 7 } }] })).toStrictEqual({
-      values: [5, 7],
-      where: 'where ("id"=$1 or "x">$2)',
-    });
-    expect(mkWhere({ or: [{ id: 5 }, { x: 7, y: 8 }] })).toStrictEqual({
-      values: [5, 7, 8],
-      where: 'where ("id"=$1 or "x"=$2 and "y"=$3)',
-    });
-    expect(mkWhere({ not: { id: 5 } })).toStrictEqual({
-      values: [5],
-      where: 'where not ("id"=$1)',
-    });
-    expect(mkWhere({ not: { id: 5, y: 1 } })).toStrictEqual({
-      values: [5, 1],
-      where: 'where not ("id"=$1 and "y"=$2)',
-    });
-    expect(mkWhere({ not: { y: { in: [1, 2, 3] } } })).toStrictEqual({
-      values: [[1, 2, 3]],
-      where: 'where not ("y" = ANY ($1))',
-    });
-    expect(mkWhere({ y: { in: [1, 2, 3] } })).toStrictEqual({
-      values: [[1, 2, 3]],
-      where: 'where "y" = ANY ($1)',
-    });
-    /*
-    TODO
-    expect(mkWhere([{ id: 5 }, { x: 7 }])).toStrictEqual({
-      values: [5, 7],
-      where: 'where "id"=$1 and "x"=$2',
-    });
-    expect(mkWhere([{ or: [{ id: 5 }, { x: 7 }] }, { z: 9 }])).toStrictEqual({
-      values: [5, 7, 9],
-      where: 'where ("id"=$1 or "x"=$2) and "z"=$3',
-    });*/
-  });
-});
-
 describe("where", () => {
   it("should support in", async () => {
     await Table.create("myothertable");

package/db/index.js

@@ -10,28 +10,33 @@
  * @namespace db_overview
  * @property {module:db/connect} connect
  * @property {module:db/fixtures} fixtures
- * @property {module:db/internal} internal
- * @property {module:db/multi-tenant} multi-tenant
- * @property {module:db/pg} pg
  * @property {module:db/reset_schema} reset_schema
- * @property {module:db/single-tenant} single-tenant
- * @property {module:db/sqlite} sqlite
  * @property {module:db/state} state
  * @property {module:db/connect} connect
- * @property {module:db/tenants} tenants
  * 
  * @category saltcorn-data
  * @subcategory db 
  */
 const { getConnectObject, is_sqlite } = require("./connect");
-const { sqlsanitize, mkWhere } = require("./internal");
+const { sqlsanitize, mkWhere } = require("@saltcorn/db-common/internal");
 var connectObj = getConnectObject();
 
-/** @type {db/sqlite|db/pg} */
-const dbmodule = is_sqlite(connectObj) ? require("./sqlite") : require("./pg");
+/** @type {db/sqlite|db/pg|null} */
+let dbmodule = null;
+try {
+  if(is_sqlite(connectObj)) {
+    dbmodule = require("@saltcorn/sqlite/sqlite");
+    dbmodule.init(getConnectObject);
+  }
+  else
+    dbmodule = require("@saltcorn/postgres/postgres")(getConnectObject);
+} catch(e) {
+  console.log("No database package found.")
+  throw e;
+}
 
 /** @type {db/tenant} */
-const tenant = require("./tenants");
+const tenant = require("@saltcorn/db-common/tenants")(getConnectObject());
 
 /** @type {boolean} */
 const isSQLite = is_sqlite(connectObj);

package/db/state.js

@@ -21,7 +21,11 @@ const { migrate } = require("../migrate");
 const File = require("../models/file");
 const Trigger = require("../models/trigger");
 const View = require("../models/view");
-const { getAllTenants, createTenant } = require("../models/tenant");
+const {
+  getAllTenants,
+  createTenant,
+  copy_tenant_template,
+} = require("../models/tenant");
 const {
   getAllConfigOrDefaults,
   setConfig,
@@ -35,7 +39,7 @@ const path = require("path");
 const fs = require("fs");
 
 /**
- * @param {object} v 
+ * @param {object} v
  * @returns {void}
  */
 const process_send = (v) => {
@@ -43,14 +47,14 @@ const process_send = (v) => {
 };
 
 /**
-  * State Class
-  * @category saltcorn-data
-  */
+ * State Class
+ * @category saltcorn-data
+ */
 class State {
   /**
-    * State constructor
-    * @param {string} tenant description
-    */
+   * State constructor
+   * @param {string} tenant description
+   */
   constructor(tenant) {
     this.tenant = tenant;
     this.views = [];
@@ -483,16 +487,16 @@ class State {
   }
 
   /**
-   * 
-   * @param {function} f 
+   *
+   * @param {function} f
    */
   setRoomEmitter(f) {
     this.roomEmitter = f;
   }
 
   /**
-   * 
-   * @param {*} args 
+   *
+   * @param {*} args
    */
   emitRoom(...args) {
     if (this.roomEmitter) this.roomEmitter(...args);
@@ -610,11 +614,29 @@ const init_multi_tenant = async (plugin_loader, disableMigrate) => {
  * @param {boolean} noSignalOrDB
  * @returns {Promise<void>}
  */
-const create_tenant = async (t, plugin_loader, newurl, noSignalOrDB) => {
+const create_tenant = async (
+  t,
+  plugin_loader,
+  newurl,
+  noSignalOrDB,
+  loadAndSaveNewPlugin
+) => {
   if (!noSignalOrDB) await createTenant(t, newurl);
   tenants[t] = new State(t);
   await db.runWithTenant(t, plugin_loader);
-  if (!noSignalOrDB) process_send({ createTenant: t });
+  if (!noSignalOrDB) {
+    const tenant_template = singleton.getConfig("tenant_template");
+    if (tenant_template) {
+      //create backup
+      await copy_tenant_template({
+        tenant_template,
+        target: t,
+        state: tenants[t],
+        loadAndSaveNewPlugin,
+      });
+    }
+    process_send({ createTenant: t });
+  }
 };
 /**
  * Restart tenant

package/models/config.js

@@ -16,7 +16,7 @@ const defaultTimezone = moment.tz.guess();
 
 /**
  * Config variables types
- * @namespace 
+ * @namespace
  * @category saltcorn-data
  */
 const configTypes = {
@@ -237,6 +237,12 @@ const configTypes = {
       "Show a warning to users creating a tenant disclaiming warrenty of availability or security",
   },
   /** @type {object} */
+  tenant_template: {
+    type: "Tenant",
+    label: "New tenant template",
+    blurb: "Copy site structure for new tenants from this tenant",
+  },
+  /** @type {object} */
   development_mode: {
     type: "Bool",
     label: "Development mode",

package/models/expression.js

@@ -9,7 +9,7 @@ const estraverse = require("estraverse");
 const astring = require("astring");
 
 /**
- * @param {string} s 
+ * @param {string} s
  * @returns {boolean|void}
  */
 function expressionValidator(s) {
@@ -23,7 +23,7 @@ function expressionValidator(s) {
 }
 
 /**
- * @param {string} expression 
+ * @param {string} expression
  * @returns {string}
  */
 function jsexprToSQL(expression) {
@@ -32,11 +32,11 @@ function jsexprToSQL(expression) {
 }
 
 /**
- * @param {string} expression 
+ * @param {string} expression
  * @throws {Error}
  * @returns {object}
  */
-function jsexprToWhere(expression) {
+function jsexprToWhere(expression, extraCtx = {}) {
   if (!expression) return {};
   try {
     const ast = acorn.parseExpressionAt(expression, 0, {
@@ -47,18 +47,26 @@ function jsexprToWhere(expression) {
     const compile = (node) =>
       ({
         BinaryExpression() {
+          const cleft = compile(node.left);
+          const cright = compile(node.right);
+          const cmp =
+            typeof cleft === "string" || cleft === null
+              ? { eq: [cleft, cright] }
+              : typeof cleft === "symbol"
+              ? { [cleft.description]: cright }
+              : { [cleft]: cright };
           return {
-            "=="({ left, right }) {
-              return { [compile(left)]: compile(right) };
+            "=="() {
+              return cmp;
             },
-            "==="({ left, right }) {
-              return { [compile(left)]: compile(right) };
+            "==="() {
+              return cmp;
             },
-            "!="({ left, right }) {
-              return { not: { [compile(left)]: compile(right) } };
+            "!="() {
+              return { not: cmp };
             },
-            "!=="({ left, right }) {
-              return { not: { [compile(left)]: compile(right) } };
+            "!=="() {
+              return { not: cmp };
             },
           }[node.operator](node);
         },
@@ -83,14 +91,18 @@ function jsexprToWhere(expression) {
           }[node.operator](node);
         },
         Identifier({ name }) {
-          return name;
+          if (name[0] === "$") {
+            return extraCtx[name.substring(1)] || null;
+          }
+          return Symbol(name);
         },
         Literal({ value }) {
           return value;
         },
       }[node.type](node));
     return compile(ast);
-  } catch {
+  } catch (e) {
+    console.error(e);
     throw new Error(
       `Expression "${expression}" is too complicated, I do not understand`
     );
@@ -98,8 +110,8 @@ function jsexprToWhere(expression) {
 }
 
 /**
- * @param {string} expression 
- * @param {object[]} statefuns 
+ * @param {string} expression
+ * @param {object[]} statefuns
  * @returns {object}
  */
 function transform_for_async(expression, statefuns) {
@@ -125,8 +137,8 @@ function transform_for_async(expression, statefuns) {
 }
 
 /**
- * @param {string} expression 
- * @param {object[]} fields 
+ * @param {string} expression
+ * @param {object[]} fields
  * @returns {any}
  */
 function get_expression_function(expression, fields) {
@@ -142,8 +154,8 @@ function get_expression_function(expression, fields) {
 }
 
 /**
- * @param {string} expression 
- * @param {object[]} fields 
+ * @param {string} expression
+ * @param {object[]} fields
  * @param {object} [extraContext = {}]
  * @returns {any}
  */
@@ -162,9 +174,9 @@ function get_async_expression_function(expression, fields, extraContext = {}) {
 }
 
 /**
- * @param {object[]} rows 
- * @param {object[]} fields 
- * @returns {object[]} 
+ * @param {object[]} rows
+ * @param {object[]} fields
+ * @returns {object[]}
  */
 function apply_calculated_fields(rows, fields) {
   let hasExprs = false;
@@ -196,8 +208,8 @@ function apply_calculated_fields(rows, fields) {
 }
 
 /**
- * @param {*} row 
- * @param {*} fields 
+ * @param {*} row
+ * @param {*} fields
  * @returns {Promise<any>}
  */
 const apply_calculated_fields_stored = async (row, fields) => {