@saltcorn/history-control 0.3.1 → 0.4.1

package/common.js

@@ -2,7 +2,7 @@ const Table = require("@saltcorn/data/models/table");
 const db = require("@saltcorn/data/db");
 const { mkWhere } = require("@saltcorn/db-common/internal");
 
-const runQuery = async (table, whereFull) => {
+const get_where_vals = (table_name, whereFull) => {
   if (whereFull?._fts?.fields) {
     whereFull._fts.fields = whereFull?._fts?.fields.filter(
       (f) => f.name !== "_version_id" && f.name !== "_deleted"
@@ -18,22 +18,28 @@ const runQuery = async (table, whereFull) => {
     where = `${
       where ? where + " and" : "where"
     } h._version = (select max(ih._version) from ${schemaPrefix}"${db.sqlsanitize(
-      table.name
+      table_name
     )}__history" ih where ih.id = h.id)`;
   }
   if (_deleted === false || _deleted === "false")
     where = `${
       where ? where + " and " : "where"
     } exists(select id from ${schemaPrefix}"${db.sqlsanitize(
-      table.name
+      table_name
     )}" t where t.id = h.id)`;
   else if (_deleted)
     where = `${
       where ? where + " and " : "where"
     } not exists(select id from ${schemaPrefix}"${db.sqlsanitize(
-      table.name
+      table_name
     )}" t where t.id = h.id)`;
 
+  return { where, values };
+};
+
+const runQuery = async (table, whereFull, opts) => {
+  const schemaPrefix = db.getTenantSchemaPrefix();
+  const { where, values } = get_where_vals(table.name, whereFull);
   const sql = `select 
  _version || '_'|| id as _version_id, 
  _version = (select max(ih._version) from ${schemaPrefix}"${db.sqlsanitize(
@@ -44,8 +50,117 @@ const runQuery = async (table, whereFull) => {
   )}" t where t.id = h.id) as _deleted, 
  * from ${schemaPrefix}"${db.sqlsanitize(table.name)}__history" h ${
     where.length ? ` ${where}` : ""
+  }${
+    opts.orderBy && opts.orderBy !== "_version_id"
+      ? ` order by "${db.sqlsanitize(opts.orderBy)}"${
+          opts.orderDesc ? " DESC" : ""
+        }`
+      : ""
+  }${opts.limit ? ` limit ${+opts.limit}` : ""}${
+    opts.offset ? ` offset ${+opts.offset}` : ""
   }`;
   return await db.query(sql, values);
 };
 
-module.exports = { runQuery };
+const updateRow = async (table_name, update_in, version_id) => {
+  const { _version_id, _is_latest, _deleted, ...update } = update_in;
+  const schemaPrefix = db.getTenantSchemaPrefix();
+  const sqlParts = [],
+    values = [];
+  const nkeys = Object.keys(update).length;
+  const [version, id] = version_id.split("_");
+  Object.entries(update).forEach(([k, v], ix) => {
+    sqlParts.push(`"${db.sqlsanitize(k)}"=$${ix + 1}`);
+    values.push(v);
+  });
+  values.push(version);
+  values.push(id);
+  const sql = `update ${schemaPrefix}"${db.sqlsanitize(
+    table_name
+  )}__history" SET ${sqlParts.join()} where _version = $${
+    nkeys + 1
+  } and id = $${nkeys + 2}`;
+  await db.query(sql, values);
+  return {};
+};
+
+const insertRow = async (table, rec_in) => {
+  const { _is_latest, _deleted, _version_id, ...rec } = rec_in;
+  const kvs = Object.entries(rec);
+  const fnameList = kvs.map(([k, v]) => `"${db.sqlsanitize(k)}"`).join();
+  var valPosList = [];
+  var valList = [];
+  const schemaPrefix = db.getTenantSchemaPrefix();
+
+  kvs.forEach(([k, v]) => {
+    valList.push(v);
+    valPosList.push(`$${valList.length}`);
+  });
+  const sql =
+    valPosList.length > 0
+      ? `insert into ${schemaPrefix}"${db.sqlsanitize(
+          table.name
+        )}__history"(${fnameList}) values(${valPosList.join()}) returning "${
+          table.pk_name || "id"
+        }"`
+      : `insert into ${schemaPrefix}"${db.sqlsanitize(
+          table.name
+        )}" DEFAULT VALUES returning "${table.pk_name || "id"}"`;
+  const { rows } = await db.query(sql, valList);
+  return rows[0][table.pk_name || "id"];
+};
+
+const countRows = async (table_name, whereFull) => {
+  const schemaPrefix = db.getTenantSchemaPrefix();
+  const { where, values } = get_where_vals(table_name, whereFull);
+  const sql = `select count(*) from ${schemaPrefix}"${db.sqlsanitize(
+    table_name
+  )}__history" h ${where.length ? ` ${where}` : ""}`;
+  const { rows } = await db.query(sql, values);
+  //console.log(rows);
+  return +rows?.[0]?.count;
+};
+
+const deleteRows = async (table_name, whereFull) => {
+  const schemaPrefix = db.getTenantSchemaPrefix();
+  const { where, values } = get_where_vals(table_name, whereFull);
+  const sql = `delete from ${schemaPrefix}"${db.sqlsanitize(
+    table_name
+  )}__history" h ${where.length ? ` ${where}` : ""}`;
+  await db.query(sql, values);
+};
+
+const distinctValues = async (table_name, fieldnm, whereObj) => {
+  const schemaPrefix = db.getTenantSchemaPrefix();
+
+  if (whereObj) {
+    const { where, values } = mkWhere(whereObj, db.isSQLite);
+    const res = await db.query(
+      `select distinct "${db.sqlsanitize(
+        fieldnm
+      )}" from ${schemaPrefix}"${db.sqlsanitize(
+        table_name
+      )}__history" ${where} order by "${db.sqlsanitize(fieldnm)}"`,
+      values
+    );
+    return res.rows.map((r) => r[fieldnm]);
+  } else {
+    const res = await db.query(
+      `select distinct "${db.sqlsanitize(
+        fieldnm
+      )}" from ${schemaPrefix}"${db.sqlsanitize(
+        table_name
+      )}__history" order by "${db.sqlsanitize(fieldnm)}"`
+    );
+    return res.rows.map((r) => r[fieldnm]);
+  }
+};
+
+module.exports = {
+  runQuery,
+  countRows,
+  deleteRows,
+  updateRow,
+  insertRow,
+  distinctValues,
+};

package/diffview.js

@@ -125,7 +125,7 @@ const run = async (
       const oldH = cmpMode === "Latest" ? row[diff_field] : cmpTo[diff_field];
       const newH = cmpMode === "Latest" ? cmpTo[diff_field] : row[diff_field];
       diff_html = HtmlDiff.default.execute(oldH, newH);
-      console.log({ oldH, newH, diff_html });
+      //console.log({ oldH, newH, diff_html });
     }
   }
 

package/index.js

@@ -9,7 +9,7 @@ const actions = {
     requireRow: true,
     run: async ({ table, row, user }) => {
       if (!table.versioned) return { error: "History not enabled for table" };
-      await table.undo_row_changes(row.id, user);
+      await table.undo_row_changes(row[table.pk_name], user);
       return { reload_page: true };
     },
   },
@@ -17,7 +17,7 @@ const actions = {
     requireRow: true,
     run: async ({ table, row, user }) => {
       if (!table.versioned) return { error: "History not enabled for table" };
-      await table.redo_row_changes(row.id, user);
+      await table.redo_row_changes(row[table.pk_name], user);
       return { reload_page: true };
     },
   },
@@ -79,7 +79,7 @@ const undelete_cascaded = async (table, row) => {
     )
       continue;
 
-    const crows = await runQuery(ctable, { [field.name]: row.id });
+    const crows = await runQuery(ctable, { [field.name]: row[table.pk_name] });
     for (const crow of crows.rows) {
       if (crow._deleted && crow._is_latest) {
         const insRow = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/history-control",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Allow users to interact with row history",
   "main": "index.js",
   "dependencies": {

package/table-provider.js

@@ -7,7 +7,14 @@ const Table = require("@saltcorn/data/models/table");
 const { getState } = require("@saltcorn/data/db/state");
 const { mkTable } = require("@saltcorn/markup");
 const { pre, code } = require("@saltcorn/markup/tags");
-const { runQuery } = require("./common");
+const {
+  runQuery,
+  countRows,
+  deleteRows,
+  updateRow,
+  insertRow,
+  distinctValues,
+} = require("./common");
 const configuration_workflow = (req) =>
   new Workflow({
     steps: [
@@ -42,7 +49,12 @@ module.exports = {
 
       const table = Table.findOne({ name: cfg.table });
       return [
-        { name: "_version_id", type: "String", primary_key: true },
+        {
+          name: "_version_id",
+          type: "String",
+          primary_key: true,
+          is_unique: true,
+        },
         ...table.fields.map((f) => {
           f.primary_key = false;
           f.validator = undefined;
@@ -64,10 +76,26 @@ module.exports = {
     },
     get_table: (cfg) => {
       return {
+        disableFiltering: true,
+        deleteRows: async (where, user) => {
+          return await deleteRows(cfg.table, where, user);
+        },
+        updateRow: async (update, version_id, user) => {
+          return await updateRow(cfg.table, update, version_id);
+        },
+        insertRow: async (rec, user) => {
+          const table = Table.findOne({ name: cfg.table });
+          return await insertRow(table, rec);
+        },
+        countRows: async (where, opts) => {
+          return await countRows(cfg.table, where || {});
+        },
+        distinctValues: async (fldNm, opts) => {
+          return await distinctValues(cfg.table, fldNm, opts);
+        },
         getRows: async (where, opts) => {
           const table = Table.findOne({ name: cfg.table });
-
-          const qres = await runQuery(table, where);
+          const qres = await runQuery(table, where, opts);
           return qres.rows;
         },
       };