@saltcorn/server 1.6.0-beta.6 → 1.6.0-beta.8

package/routes/fields.js

@@ -248,7 +248,20 @@ const fieldFlow = (req) =>
     onDone: async (context) => {
       //const thetype = getState().types[context.type];
       const attributes = context.attributes || {};
-      attributes.default = context.default;
+      // attributes.default = context.default;
+
+      const setDefault =
+        context.set_default === undefined || context.set_default === true;
+      if (setDefault && context.default_type === "expression") {
+        attributes.default_expression = context.default_expression;
+        attributes.default = undefined;
+      } else if (setDefault) {
+        attributes.default = context.default;
+        attributes.default_expression = undefined;
+      } else {
+        attributes.default = undefined;
+        attributes.default_expression = undefined;
+      }
       attributes.summary_field = context.summary_field;
       attributes.include_fts = context.include_fts;
       attributes.on_delete_cascade = context.on_delete_cascade;
@@ -573,11 +586,12 @@ const fieldFlow = (req) =>
               {
                 name: "aggwhere",
                 label: req.__("Where"),
-                sublabel: req.__("Formula"),
-                class: "validate-expression",
-                type: "String",
                 required: false,
                 showIf: { expression_type: "Aggregation" },
+                sublabel: req.__(`Formula evaluating to boolean. Example: <code>status === "Active"</code>`),
+                class: "validate-expression",
+                type: "String",
+                help: { topic: "Aggregation where formula" },
               },
               ...agg_order_opts,
               {
@@ -753,10 +767,9 @@ const fieldFlow = (req) =>
           const nrows = await table.countRows();
           const formfield = new Field({
             name: "default",
-            label: req.__("Default"),
-            // todo sublabel
+            label: req.__("Default value"),
             type: context.type,
-            required: true,
+            required: false,
             attributes: {
               summary_field: context.summary_field,
               ...(context.attributes || {}),
@@ -764,7 +777,61 @@ const fieldFlow = (req) =>
           });
           await formfield.fill_fkey_options();
           const defaultOptional = nrows === 0 || context.id;
-          if (defaultOptional) formfield.showIf = { set_default: true };
+          const setDefaultShowIf = defaultOptional
+            ? { set_default: true }
+            : undefined;
+
+          if (setDefaultShowIf)
+            formfield.showIf = {
+              ...setDefaultShowIf,
+              default_type: "fixed",
+            };
+          else formfield.showIf = { default_type: "fixed" };
+
+          const defaultTypeOptions = [
+            { label: req.__("Fixed value"), name: "fixed" },
+            { label: req.__("Expression"), name: "expression" },
+          ];
+
+          const expressionShowIf = setDefaultShowIf
+            ? { ...setDefaultShowIf, default_type: "expression" }
+            : { default_type: "expression" };
+
+          const attrEscape = (s) =>
+            s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+          const presets = [
+            {
+              label: req.__("Current user ID"),
+              expr: "user && user.id",
+            },
+            {
+              label: req.__("Current user email"),
+              expr: "user && user.email",
+            },
+            {
+              label: req.__("Current timestamp"),
+              expr: "new Date()",
+            },
+            {
+              label: req.__("Current date (ISO)"),
+              expr: "new Date().toISOString().substring(0, 10)",
+            },
+          ];
+          const presetButtons = presets
+            .map(
+              (p) =>
+                `<button type="button" class="btn btn-sm btn-outline-secondary me-1 mb-1" onclick="setDefaultExpressionValue(${attrEscape(JSON.stringify(p.expr))})">${p.label}</button>`
+            )
+            .join("");
+          const setterScript = `<script>
+function setDefaultExpressionValue(val) {
+  var ta = document.querySelector('[name="default_expression"]');
+  if (!ta) return;
+  var monacoDiv = ta.nextElementSibling;
+  var ed = monacoDiv && $(monacoDiv).data && $(monacoDiv).data("monaco-editor");
+  if (ed) { ed.setValue(val); } else { ta.value = val; }
+}
+</script>`;
 
           const form = new Form({
             blurb: defaultOptional
@@ -774,16 +841,51 @@ const fieldFlow = (req) =>
                 ),
             fields: [
               ...(defaultOptional
-                ? [{ name: "set_default", label: "Set Default", type: "Bool" }]
+                ? [
+                    {
+                      name: "set_default",
+                      label: req.__("Set Default"),
+                      type: "Bool",
+                    },
+                  ]
                 : []),
+              {
+                name: "default_type",
+                label: req.__("Default type"),
+                type: "String",
+                attributes: {
+                  options: defaultTypeOptions,
+                },
+                showIf: setDefaultShowIf,
+              },
               formfield,
+              {
+                name: "default_expression",
+                label: req.__("Expression"),
+                sublabel:
+                  req.__(
+                    "JavaScript expression. Available: <code>user</code> (current user). Can be async."
+                  ) + `<div class="mt-1">${presetButtons}</div>${setterScript}`,
+                input_type: "code",
+                attributes: {
+                  mode: "application/javascript",
+                  user: true,
+                },
+                showIf: expressionShowIf,
+              },
             ],
           });
-          if (
+          const hasExprDefault = !!context.default_expression;
+          const hasFixedDefault =
             typeof context.default !== "undefined" &&
-            context.default !== null
-          )
+            context.default !== null &&
+            !hasExprDefault;
+          if (hasExprDefault || hasFixedDefault) {
             form.values.set_default = true;
+            form.values.default_type = hasExprDefault ? "expression" : "fixed";
+          } else {
+            form.values.default_type = "fixed";
+          }
           return form;
         },
       },
@@ -1003,7 +1105,7 @@ router.post(
     try {
       if (stored) {
         const f = get_async_expression_function(formula, fields);
-        result = await f(rows[0]);
+        result = await f(rows[0], req.user);
       } else {
         const f = get_expression_function(formula, fields);
         result = f(rows[0]);

package/routes/homepage.js

@@ -621,7 +621,10 @@ const get_config_response = async (role_id, res, req) => {
     );
 
     if (contents.html_file) await sendHtmlFile(req, res, contents.html_file);
-    else
+    else if (contents.html_string) {
+      res.set("Content-Type", "text/html");
+      await res.send(contents.html_string);
+    } else
       res.sendWrap(
         {
           title: title || "",

package/routes/list.js

@@ -181,10 +181,11 @@ const typeToGridType = (t, field) => {
       format: "iso",
     };
     jsgField.editor = "__flatpickerEditor";
-    jsgField.formatter = "datetime";
-    jsgField.formatterParams = {
-      inputFormat: "iso",
-    };
+    // jsgField.formatter = "datetime";
+    // jsgField.formatterParams = {
+    //   inputFormat: "iso",
+    // };
+    jsgField.formatter = "__isoDateTimeFormatter";
 
     if (field.attributes?.day_only) {
       jsgField.editorParams = { dayOnly: true };
@@ -432,30 +433,67 @@ router.get(
                 })
               })
               window.tabulator_table_primary_key = "${table.pk_name}";
+              function tabulator_fill_height() {
+                const el = document.getElementById('jsGrid');
+                if (!el) return 400;
+                return Math.max(200, Math.floor(window.innerHeight - el.getBoundingClientRect().top - 10));
+              }
+              function tabulator_calc_page_size() {
+                const holder = document.querySelector('#jsGrid .tabulator-tableholder');
+                if (!holder) return 20;
+                const rowH = window._tab_row_height || 35;
+                return Math.max(5, Math.floor(holder.clientHeight / rowH));
+              }
+              const _tab_h = tabulator_fill_height();
               window.tabulator_table = new Tabulator("#jsGrid", {
                   ajaxURL:"/api/${encodeURIComponent(
                     table.name
                   )}?tabulator_pagination_format=true${
                     table.versioned ? "&versioncount=on" : ""
-                  }",                   
-                  layout:"fitData", 
+                  }",
+                  layout:"fitDataFill",
                   columns,
-                  height:"100%",
+                  height: _tab_h,
                   pagination:true,
                   paginationMode:"remote",
-                  paginationSize:20,
-                  clipboard:true,                 
+                  paginationSize: tabulator_calc_page_size(),
+                  clipboard:true,
                   movableColumns: true,
                   ajaxContentType:"json",
                   sortMode:"remote",
-                  resizableColumnGuide:true,                  
+                  resizableColumnGuide:true,
                   columnDefaults:{
                       resizable:true,
                       maxWidth:500
                   },
                   initialSort:[
                     {column:"${table.pk_name}", dir:"asc"},
-                  ],                 
+                  ],
+              });
+              window.tabulator_table.on("tableBuilt", function() {
+                const ps = tabulator_calc_page_size();
+                if (ps !== window.tabulator_table.getPageSize())
+                  window.tabulator_table.setPageSize(ps);
+              });
+              window.tabulator_table.on("dataLoaded", function() {
+                if (window._tab_row_height) return;
+                const rows = window.tabulator_table.getRows();
+                if (!rows.length) return;
+                window._tab_row_height = rows[0].getElement().offsetHeight;
+                const ps = tabulator_calc_page_size();
+                if (ps !== window.tabulator_table.getPageSize())
+                  window.tabulator_table.setPageSize(ps);
+              });
+              let _tab_resize_timer;
+              window.addEventListener('resize', function() {
+                clearTimeout(_tab_resize_timer);
+                _tab_resize_timer = setTimeout(function() {
+                  const h = tabulator_fill_height();
+                  window.tabulator_table.setHeight(h);
+                  const ps = tabulator_calc_page_size();
+                  if (ps !== window.tabulator_table.getPageSize())
+                    window.tabulator_table.setPageSize(ps);
+                }, 150);
               });
               window.allnonecols= (do_show, e) =>{
                 columns.forEach(col=>{

package/routes/plugins.js

@@ -34,6 +34,8 @@ const {
   plugin_viewtemplates_info_card,
   showRepository,
 } = require("../markup/plugin-store");
+const MarkdownIt = require("markdown-it"),
+  md = new MarkdownIt();
 const {
   h5,
   a,
@@ -56,6 +58,8 @@ const {
   text,
   script,
   domReady,
+  details,
+  summary,
 } = require("@saltcorn/markup/tags");
 const { search_bar } = require("@saltcorn/markup/helpers");
 const fs = require("fs");
@@ -208,6 +212,7 @@ const get_store_items = async (req) => {
       plugin: true,
       description: plugin.description,
       documentation_link: plugin.documentation_link,
+      contents: plugin.contents,
       has_theme: plugin.has_theme,
       has_auth: plugin.has_auth,
       unsafe: plugin.unsafe,
@@ -323,6 +328,9 @@ const store_item_html = (req) => (item) => ({
       item.ready_for_mobile && badge(req.__("Mobile"))
     ),
     div(item.description || ""),
+    item.contents
+      ? details(summary(req.__("Detailed contents")), md.render(item.contents))
+      : "",
     item.documentation_link
       ? div(
           a(
@@ -467,7 +475,11 @@ const match_string = (s, q) => {
  * @returns {boolean}
  */
 const satisfy_q = (p, q) => {
-  return match_string(p.name, q) || match_string(p.description, q);
+  return (
+    match_string(p.name, q) ||
+    match_string(p.description, q) ||
+    match_string(p.contents, q)
+  );
 };
 
 /**
@@ -715,7 +727,8 @@ router.get(
                       label: version,
                       selected: version === selected,
                     })
-                  ).reverse()
+                  )
+                  .reverse()
               ),
               // tag
               label(
@@ -1287,9 +1300,10 @@ router.get(
     let latest =
       update_permitted &&
       (await get_latest_npm_version(plugin_db.location, 1000));
+    let isNpm = plugin_db.source === "npm";
     let engineInfos = await Plugin.getEngineInfos(plugin_db); // with cache
     let forceFetch = true;
-    if (latest && !engineInfos[latest]) {
+    if (latest && !engineInfos[latest] && isNpm) {
       engineInfos = await Plugin.getEngineInfos(plugin_db, forceFetch);
       forceFetch = false;
     }
@@ -1371,6 +1385,12 @@ router.get(
               )
             )
           : null,
+        store_item && store_item.contents
+          ? tr(
+              th(req.__("Detailed contents")),
+              td(md.render(store_item.contents))
+            )
+          : null,
         pkgjson && pkgjson.repository
           ? tr(th(req.__("Repository")), td(showRepository(pkgjson.repository)))
           : null

package/routes/tables.js

@@ -8,6 +8,7 @@ const Router = require("express-promise-router");
 
 const db = require("@saltcorn/data/db");
 const Table = require("@saltcorn/data/models/table");
+const Field = require("@saltcorn/data/models/field");
 const File = require("@saltcorn/data/models/file");
 const View = require("@saltcorn/data/models/view");
 const User = require("@saltcorn/data/models/user");
@@ -847,6 +848,18 @@ router.get(
     let fieldCard;
     const primaryKeys = fields.filter((f) => f.primary_key);
     const nPrimaryKeys = primaryKeys.length;
+    const standardFieldNames = [
+      "name",
+      "description",
+      "created_at",
+      "updated_at",
+      "created_by",
+      "updated_by",
+    ];
+    const fieldNameSet = new Set(fields.map((f) => f.name));
+    const hasAllStandardFields = standardFieldNames.every((n) =>
+      fieldNameSet.has(n)
+    );
 
     if (fields.length === 0) {
       fieldCard = [
@@ -862,6 +875,17 @@ router.get(
             },
             req.__("Add field to table")
           ),
+        !table.external &&
+          !table.provider_name &&
+          user_can_edit_tables &&
+          !hasAllStandardFields &&
+          a(
+            {
+              class: "btn btn-outline-secondary ms-2",
+              href: `javascript:ajax_modal('/table/create-standard-fields/${table.id}')`,
+            },
+            req.__("Create standard fields")
+          ),
       ];
     } else {
       const tableHtml = mkTable(
@@ -946,6 +970,17 @@ router.get(
             },
             req.__("Add field")
           ),
+        !table.external &&
+          !table.provider_name &&
+          user_can_edit_tables &&
+          !hasAllStandardFields &&
+          a(
+            {
+              class: "btn btn-outline-secondary ms-2 mt-2",
+              href: `javascript:ajax_modal('/table/create-standard-fields/${table.id}')`,
+            },
+            req.__("Create standard fields")
+          ),
       ];
     }
     let viewCard;
@@ -1789,8 +1824,13 @@ const constraintForm = (req, table, fields, type) => {
             name: "formula",
             label: req.__("Constraint formula"),
             validator: expressionValidator,
-            type: "String",
-            class: "validate-expression",
+            input_type: "code",
+            attributes: {
+              mode: "application/javascript",
+              singleline: true,
+              table: table.name,
+              expression_type: "boolean",
+            },
             help: {
               topic: "Table formula constraint",
               context: { table: table.name },
@@ -2682,3 +2722,134 @@ router.post(
     res.redirect(`/table/${table.id}`);
   })
 );
+
+const standardFieldDefs = (req) => [
+  {
+    name: "name",
+    label: req.__("Name"),
+    type: "String",
+    fieldType: "String",
+  },
+  {
+    name: "description",
+    label: req.__("Description"),
+    type: "String",
+    fieldType: "String",
+  },
+  {
+    name: "created_at",
+    label: req.__("Created at"),
+    type: "Date",
+    fieldType: "Date",
+    required: true,
+    attributes: { default_expression: "new Date()" },
+  },
+  {
+    name: "updated_at",
+    label: req.__("Updated at"),
+    type: "Date",
+    fieldType: "Date",
+    calculated: true,
+    stored: true,
+    expression: "new Date()",
+  },
+  {
+    name: "created_by",
+    label: req.__("Created by"),
+    type: "Key to user",
+    fieldType: "Key",
+    reftable_name: "users",
+    attributes: { default_expression: "user?.id", summary_field: "email" },
+  },
+  {
+    name: "updated_by",
+    label: req.__("Updated by"),
+    type: "Key to user",
+    fieldType: "Key",
+    reftable_name: "users",
+    calculated: true,
+    stored: true,
+    expression: "user?.id ?? row?.updated_by",
+    attributes: { summary_field: "email" },
+  },
+];
+
+const standardFieldForm = (table, req, existingNames = new Set()) => {
+  const defs = standardFieldDefs(req).filter(
+    (def) => !existingNames.has(def.name)
+  );
+  return new Form({
+    submitLabel: req.__("Create fields"),
+    action: `/table/create-standard-fields/${table.id}`,
+    formStyle: "vert",
+    fields: defs.map((def) => ({
+      type: "Bool",
+      label: `${def.label} (${def.type})`,
+      name: def.name,
+      default: true,
+    })),
+  });
+};
+
+router.get(
+  "/create-standard-fields/:id",
+  isAdminOrHasConfigMinRole("min_role_edit_tables"),
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+    const table = Table.findOne({ id });
+    if (!table) {
+      req.flash("error", `Table not found`);
+      res.redirect(`/table`);
+      return;
+    }
+    const existingFields = await table.getFields();
+    const existingNames = new Set(existingFields.map((f) => f.name));
+    res.set("Page-Title", req.__("Create standard fields"));
+    const form = standardFieldForm(table, req, existingNames);
+    res.send(renderForm(form, req.csrfToken()));
+  })
+);
+
+router.post(
+  "/create-standard-fields/:id",
+  isAdminOrHasConfigMinRole("min_role_edit_tables"),
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+    const table = Table.findOne({ id });
+    if (!table) {
+      req.flash("error", `Table not found`);
+      res.redirect(`/table`);
+      return;
+    }
+    const existingFields = await table.getFields();
+    const existingNames = new Set(existingFields.map((f) => f.name));
+    const form = standardFieldForm(table, req, existingNames);
+    form.validate(req.body || {});
+    if (form.hasErrors) {
+      req.flash("error", req.__("An error occurred"));
+      res.redirect(`/table/${table.id}`);
+      return;
+    }
+    const defs = standardFieldDefs(req);
+    await db.withTransaction(async () => {
+      for (const def of defs) {
+        if (!form.values[def.name]) continue;
+        if (existingNames.has(def.name)) continue;
+        await Field.create({
+          table_id: table.id,
+          name: def.name,
+          label: def.label,
+          type: def.fieldType,
+          reftable_name: def.reftable_name,
+          required: def.required || false,
+          calculated: def.calculated || false,
+          stored: def.stored || false,
+          expression: def.expression,
+          attributes: def.attributes || {},
+        });
+      }
+    });
+    await getState().refresh_tables();
+    res.redirect(`/table/${table.id}`);
+  })
+);

package/routes/utils.js

@@ -13,7 +13,11 @@ const {
   features,
 } = require("@saltcorn/data/db/state");
 const { get_base_url } = require("@saltcorn/data/models/config");
-const { hash } = require("@saltcorn/data/utils");
+const {
+  hash,
+  is_relative_url,
+  normalize_relative_url,
+} = require("@saltcorn/data/utils");
 const { input, script, domReady, a, text } = require("@saltcorn/markup/tags");
 const session = require("express-session");
 const cookieSession = require("cookie-session");
@@ -389,36 +393,6 @@ const addOnDoneRedirect = (oldPath, req) => {
   return oldPath;
 };
 
-const is_relative_url = (url) => {
-  if (typeof url !== "string") return false;
-
-  // Normalise backslashes to forward slashes (WHATWG treats \ as / in special schemes)
-  const normalised = url.replace(/\\/g, "/");
-
-  // Reject protocol-relative URLs (//example.com)
-  if (normalised.trimStart().startsWith("//")) return false;
-
-  // Reject any scheme: URIs (e.g. http:, javascript:, data:, vbscript:)
-  // A scheme is a letter followed by letters/digits/+/-/. then a colon (RFC 3986 §3.1)
-  if (/^[a-zA-Z][a-zA-Z0-9+\-.]*:/u.test(normalised.trimStart())) return false;
-
-  return true;
-};
-
-const normalize_relative_url = (url) => {
-  if (typeof url !== "string") return null;
-
-  const normalised = url.replace(/\\/g, "/").trimStart();
-
-  // Reject protocol-relative URLs
-  if (normalised.startsWith("//")) return null;
-
-  // Reject any scheme (RFC 3986 §3.1)
-  if (/^[a-zA-Z][a-zA-Z0-9+\-.]*:/.test(normalised)) return null;
-
-  return normalised;
-};
-
 const safe_redirect = (res, url, default_url) => {
   if (!url) {
     res.redirect(default_url);