@saltcorn/history-control 0.1.0 → 0.2.0

package/index.js

@@ -1,4 +1,5 @@
 const { features } = require("@saltcorn/data/db/state");
+const Table = require("@saltcorn/data/models/table");
 
 // user subscribe action
 const actions = {
@@ -18,9 +19,46 @@ const actions = {
       return { reload_page: true };
     },
   },
+  restore_from_history: {
+    requireRow: true,
+    run: async ({ table, row, user }) => {
+      if (table.provider_name !== "History for database table")
+        return {
+          error:
+            "Only use this action on tables provided by History for database table",
+        };
+      const real_table = Table.findOne({ name: table.provider_cfg?.table });
+      if (!real_table) return { error: "Table not found" };
+      if (!real_table.versioned)
+        return { error: "History not enabled for table" };
+      if (row._deleted) {
+        const insRow = {};
+        for (const field of real_table.fields) {
+          insRow[field.name] = row[field.name];
+        }
+        await real_table.insertRow(insRow);
+      } else {
+        const updRow = {};
+        for (const field of real_table.fields) {
+          if (!field.primary_key) updRow[field.name] = row[field.name];
+        }
+        await real_table.updateRow(
+          updRow,
+          row[real_table.pk_name],
+          user,
+          false,
+          undefined,
+          row._version
+        );
+      }
+
+      return { reload_page: true };
+    },
+  },
 };
 
 module.exports = {
   sc_plugin_api_version: 1,
   actions: features?.table_undo ? actions : undefined,
+  table_providers: require("./table-provider.js"),
 };

package/package.json

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

package/table-provider.js

@@ -0,0 +1,130 @@
+const db = require("@saltcorn/data/db");
+const { eval_expression } = require("@saltcorn/data/models/expression");
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+const FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
+const Field = require("@saltcorn/data/models/field");
+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 configuration_workflow = (req) =>
+  new Workflow({
+    steps: [
+      {
+        name: "query",
+        form: async () => {
+          const tables = await Table.find({ versioned: true });
+          return new Form({
+            fields: [
+              {
+                name: "table",
+                label: "Table",
+                type: "String",
+                required: true,
+                attributes: {
+                  options: tables.map((t) => t.name),
+                },
+                sublabel: "Select a versioned table",
+              },
+            ],
+          });
+        },
+      },
+    ],
+  });
+const runQuery = async (cfg, where, opts) => {
+  const table = Table.findOne({ name: cfg.table });
+  const wheres = [];
+  let phIndex = 1;
+  const phValues = [];
+
+  const schemaPrefix = db.getTenantSchemaPrefix();
+
+  for (const k of Object.keys(where)) {
+    if (k === "_is_latest" && where[k]) {
+      wheres.push(
+        `h._version = (select max(ih._version) from ${schemaPrefix}"${db.sqlsanitize(
+          table.name
+        )}__history" ih where ih.id = h.id)`
+      );
+      continue;
+    }
+    if (k === "_deleted") {
+      if (where[k])
+        wheres.push(
+          `not exists(select id from ${schemaPrefix}"${db.sqlsanitize(
+            table.name
+          )}" t where t.id = h.id)`
+        );
+      else
+        wheres.push(
+          `exists(select id from ${schemaPrefix}"${db.sqlsanitize(
+            table.name
+          )}" t where t.id = h.id)`
+        );
+      continue;
+    }
+    const f = table.getField(k);
+    if (f) {
+      wheres.push(
+        where[k]?.ilike ? `"${k}" ILIKE $${phIndex}` : `"${k}" = $${phIndex}`
+      );
+      phValues.push(where[k]?.ilike ? where[k]?.ilike : where[k]);
+      phIndex += 1;
+    }
+  }
+
+  const sql = `select 
+  _version || '_'|| id as _version_id, 
+  _version = (select max(ih._version) from ${schemaPrefix}"${db.sqlsanitize(
+    table.name
+  )}__history" ih where ih.id = h.id) as _is_latest,
+  not exists(select id from ${schemaPrefix}"${db.sqlsanitize(
+    table.name
+  )}" t where t.id = h.id) as _deleted, 
+  * from ${schemaPrefix}"${db.sqlsanitize(table.name)}__history" h ${
+    wheres.length ? ` where ${wheres.join(" AND")}` : ""
+  }`;
+
+  return await db.query(sql, phValues);
+};
+module.exports = {
+  "History for database table": {
+    configuration_workflow,
+    fields: (cfg) => {
+      if (!cfg?.table) return [];
+
+      const table = Table.findOne({ name: cfg.table });
+      return [
+        { name: "_version_id", type: "String", primary_key: true },
+        ...table.fields.map((f) => {
+          f.primary_key = false;
+          f.validator = undefined;
+          if (f.is_fkey) f.type = "Integer";
+          else f.type = f.type?.name || f.type;
+          return f;
+        }),
+        { name: "_version", label: "Version", type: "Integer" },
+        { name: "_is_latest", label: "Is latest", type: "Bool" },
+        { name: "_deleted", label: "Deleted", type: "Bool" },
+        { name: "_time", label: "Time", type: "Date" },
+        { name: "_userid", label: "User ID", type: "Integer" },
+        {
+          name: "_restore_of_version",
+          label: "Restore of version",
+          type: "Integer",
+        },
+      ];
+    },
+    get_table: (cfg) => {
+      return {
+        getRows: async (where, opts) => {
+          const qres = await runQuery(cfg, where, opts);
+          return qres.rows;
+        },
+      };
+    },
+  },
+};