@saltcorn/sql 0.4.4 → 0.5.1

package/agent-skill.js

@@ -0,0 +1,116 @@
+const { div, pre, a } = require("@saltcorn/markup/tags");
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+const Table = require("@saltcorn/data/models/table");
+const View = require("@saltcorn/data/models/view");
+const Trigger = require("@saltcorn/data/models/trigger");
+const { getState } = require("@saltcorn/data/db/state");
+const db = require("@saltcorn/data/db");
+const { eval_expression } = require("@saltcorn/data/models/expression");
+const { interpolate } = require("@saltcorn/data/utils");
+
+//const { fieldProperties } = require("./helpers");
+
+class SQLQuerySkill {
+  static skill_name = "SQL query";
+
+  get skill_label() {
+    return "SQL Query";
+  }
+
+  constructor(cfg) {
+    Object.assign(this, cfg);
+  }
+
+  async runQuery({ triggering_row, user }) {
+    const row = triggering_row;
+    const read_only = true;
+    const is_sqlite = db.isSQLite;
+
+    const phValues = [];
+    (this.query_parameters || "")
+      .split(",")
+      .filter((s) => s)
+      .forEach((sp0) => {
+        const sp = sp0.trim();
+        if (sp.startsWith("user.")) {
+          phValues.push(eval_expression(sp, {}, user));
+        } else if (typeof row[sp] === "undefined") phValues.push(null);
+        else phValues.push(row[sp]);
+      });
+
+    const client = is_sqlite ? db : await db.getClient();
+    await client.query(`BEGIN;`);
+    if (!is_sqlite) {
+      await client.query(`SET LOCAL search_path TO "${db.getTenantSchema()}";`);
+      if (read_only)
+        await client.query(
+          `SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY;`
+        );
+    }
+    const qres = await client.query(this.sql, phValues);
+
+    await client.query(`COMMIT;`);
+
+    if (!is_sqlite) client.release(true);
+
+    if (this.row_format) {
+      return qres.rows
+        .map((r) => interpolate(this.row_format, r, user))
+        .join("\n\n");
+    }
+    return JSON.stringify(qres.rows);
+  }
+
+  async systemPrompt({ triggering_row, user }) {
+    if (this.mode === "Preload into system prompt") {
+      const rows = await this.runQuery({ triggering_row, user });
+      return `${this.add_sys_prompt}: ${rows}`;
+    }
+    return `${this.add_sys_prompt}`;
+  }
+
+  static async configFields() {
+    return [
+      {
+        name: "mode",
+        label: "Mode",
+        type: "String",
+        required: true,
+        attributes: { options: [/*"Tool",*/ "Preload into system prompt"] },
+      },
+      {
+        name: "sql",
+        label: "SQL",
+        input_type: "code",
+        attributes: { mode: "text/x-sql" },
+        sublabel:
+          "Refer to row parameters in the order below with <code>$1</code>, <code>$2</code> etc",
+      },
+      {
+        name: "query_parameters",
+        label: "Query parameters",
+        sublabel:
+          "Comma separated list of variables to use as SQL query parameters. User variables can be used as <code>user.id</code> etc",
+        type: "String",
+        //showIf: { mode: "Tool" },
+      },
+      {
+        name: "add_sys_prompt",
+        label: "Additional prompt",
+        type: "String",
+        fieldview: "textarea",
+      },
+      {
+        name: "row_format",
+        label: "Row format",
+        type: "String",
+        fieldview: "textarea",
+        sublabel:
+          "Format of text to send to LLM, use <code>{{ }}</code> to access row fields. If not set, rows will be sent as JSON",
+      },
+    ];
+  }
+}
+
+module.exports = SQLQuerySkill;

package/index.js

@@ -5,6 +5,7 @@ const Table = require("@saltcorn/data/models/table");
 const FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
 const Workflow = require("@saltcorn/data/models/workflow");
 const { eval_expression } = require("@saltcorn/data/models/expression");
+const { interpolate } = require("@saltcorn/data/utils");
 const {
   text,
   div,
@@ -107,20 +108,24 @@ const run = async (
       );
     }
     qres = await client.query(sql, phValues);
-  } catch (e) {
-    throw e;
   } finally {
     await client.query(`ROLLBACK;`);
     if (!is_sqlite) client.release(true);
   }
   switch (output_type) {
     case "HTML":
-      const template = _.template(html_code || "", {
+      /*const template = _.template(html_code || "", {
         evaluate: /\{\{#(.+?)\}\}/g,
         interpolate: /\{\{([^#].+?)\}\}/g,
       });
-
-      return template({ rows: qres.rows });
+      console.log("template", viewname, state, html_code);*/
+      return interpolate(
+        html_code,
+        { rows: qres.rows },
+        req.user,
+        `HTML code interpolation in view ${viewname}`
+      );
+    //return template();
 
     case "JSON":
       return `<pre>${JSON.stringify(qres.rows, null, 2)}</pre>`;
@@ -138,6 +143,9 @@ module.exports = {
   plugin_name: "sql",
   actions: require("./action.js"),
   table_providers: require("./table-provider.js"),
+  exchange: {
+    agent_skills: [require("./agent-skill.js")],
+  },
   functions: {
     sqlQuery: {
       run: async (query, parameters) => {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@saltcorn/sql",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "description": "Actions and views based on SQL",
   "main": "index.js",
   "dependencies": {
     "@saltcorn/markup": "^0.6.0",
     "@saltcorn/data": "^0.6.0",
     "underscore": "1.13.6",
-    "node-sql-parser": "4.0.8",
+    "node-sql-parser": "5.3.10",
     "sqlstring": "^2.3.3"
   },
   "author": "Tom Nielsen",
@@ -15,7 +15,7 @@
   "eslintConfig": {
     "extends": "eslint:recommended",
     "parserOptions": {
-      "ecmaVersion": 2020
+      "ecmaVersion": 2022
     },
     "env": {
       "node": true,

package/table-provider.js

@@ -46,6 +46,13 @@ const configuration_workflow = (req) =>
                   }
                 },
               },
+              {
+                label: "Ignore where/order",
+                sublabel:
+                  "Always use this SQL directly without attempting to modify it",
+                type: "Bool",
+                name: "ignore_where",
+              },
             ],
           });
         },
@@ -176,161 +183,168 @@ const runQuery = async (cfg, where, opts) => {
   const opt = {
     database: is_sqlite ? "SQLite" : "PostgreSQL",
   };
-
-  const { ast } = parser.parse(sql, opt);
-
-  const colNames = new Set((cfg?.columns || []).map((c) => c.name));
-  let phIndex = 1;
+  let sqlQ;
   const phValues = [];
-  //console.log(ast[0].columns);
-  for (const k of Object.keys(where)) {
-    if (!colNames.has(k)) continue;
-    const sqlCol =
-      ast[0].columns == "*"
-        ? {
-            type: "expr",
-            expr: { type: "column_ref", table: null, column: k },
-            as: null,
-          }
-        : (ast[0].columns || []).find(
-            (c) => k === c.as || (!c.as && k === c.expr?.column)
-          );
-    const sqlExprCol =
-      ast[0].columns == "*"
-        ? {
-            type: "expr",
-            expr: { type: "column_ref", table: null, column: k },
-            as: null,
-          }
-        : (ast[0].columns || []).find((c) => c.expr?.as == k);
-    const sqlAggrCol = (ast[0].columns || []).find(
-      (c) =>
-        c.expr?.type === "aggr_func" &&
-        c.expr?.name?.toUpperCase() === k.toUpperCase()
-    );
+  if (cfg?.ignore_where) {
+    sqlQ = sql;
+  } else {
+    const { ast } = parser.parse(sql, opt);
 
-    let left = sqlExprCol
-      ? { ...sqlExprCol.expr, as: null }
-      : sqlAggrCol
-      ? { ...sqlAggrCol.expr }
-      : {
-          type: "column_ref",
-          table: sqlCol?.expr?.table,
-          column: sqlCol?.expr?.column || db.sqlsanitize(k),
-        };
-    //console.log({ k, sqlCol, sqlExprCol });
-    if (!sqlCol) {
-      const starCol = (ast[0].columns || []).find((c) => c.type === "star_ref");
-      if (starCol)
-        left = {
-          type: "column_ref",
-          table: starCol?.expr?.table,
-          column: db.sqlsanitize(k),
-        };
-    }
-    const newClause = {
-      type: "binary_expr",
-      operator: where[k]?.ilike && !sqlAggrCol ? "ILIKE" : "=",
-      left,
-      right: { type: "number", value: "$" + phIndex },
-    };
-    phIndex += 1;
-    phValues.push(where[k]?.ilike ? where[k]?.ilike : where[k]);
-    if (!sqlAggrCol) {
-      if (!ast[0].where) ast[0].where = newClause;
-      else {
-        ast[0].where = {
-          type: "binary_expr",
-          operator: "AND",
-          left: ast[0].where,
-          right: newClause,
-        };
+    const colNames = new Set((cfg?.columns || []).map((c) => c.name));
+    let phIndex = 1;
+    //console.log(ast[0].columns);
+    for (const k of Object.keys(where)) {
+      if (!colNames.has(k)) continue;
+      const sqlCol =
+        ast[0].columns == "*"
+          ? {
+              type: "expr",
+              expr: { type: "column_ref", table: null, column: k },
+              as: null,
+            }
+          : (ast[0].columns || []).find(
+              (c) => k === c.as || (!c.as && k === c.expr?.column)
+            );
+      const sqlExprCol =
+        ast[0].columns == "*"
+          ? {
+              type: "expr",
+              expr: { type: "column_ref", table: null, column: k },
+              as: null,
+            }
+          : (ast[0].columns || []).find((c) => c.expr?.as == k);
+      const sqlAggrCol = (ast[0].columns || []).find(
+        (c) =>
+          c.expr?.type === "aggr_func" &&
+          c.expr?.name?.toUpperCase() === k.toUpperCase()
+      );
+
+      let left = sqlExprCol
+        ? { ...sqlExprCol.expr, as: null }
+        : sqlAggrCol
+        ? { ...sqlAggrCol.expr }
+        : {
+            type: "column_ref",
+            table: sqlCol?.expr?.table,
+            column: sqlCol?.expr?.column || db.sqlsanitize(k),
+          };
+      //console.log({ k, sqlCol, sqlExprCol });
+      if (!sqlCol) {
+        const starCol = (ast[0].columns || []).find(
+          (c) => c.type === "star_ref"
+        );
+        if (starCol)
+          left = {
+            type: "column_ref",
+            table: starCol?.expr?.table,
+            column: db.sqlsanitize(k),
+          };
       }
-    } else {
-      if (!ast[0].having) ast[0].having = newClause;
-      else {
-        ast[0].having = {
-          type: "binary_expr",
-          operator: "AND",
-          left: ast[0].having,
-          right: newClause,
-        };
+      const newClause = {
+        type: "binary_expr",
+        operator: where[k]?.ilike && !sqlAggrCol ? "ILIKE" : "=",
+        left,
+        right: { type: "number", value: "$" + phIndex },
+      };
+      phIndex += 1;
+      phValues.push(where[k]?.ilike ? where[k]?.ilike : where[k]);
+      if (!sqlAggrCol) {
+        if (!ast[0].where) ast[0].where = newClause;
+        else {
+          ast[0].where = {
+            type: "binary_expr",
+            operator: "AND",
+            left: ast[0].where,
+            right: newClause,
+          };
+        }
+      } else {
+        if (!ast[0].having) ast[0].having = newClause;
+        else {
+          ast[0].having = {
+            type: "binary_expr",
+            operator: "AND",
+            left: ast[0].having,
+            right: newClause,
+          };
+        }
       }
     }
-  }
-  if (where?.limit && where?.offset) {
-    ast[0].limit = {
-      seperator: "offset",
-      value: [
-        { type: "number", value: where.limit },
-        { type: "number", value: where.offset },
-      ],
-    };
-  } else if (opts?.limit && opts?.offset) {
-    ast[0].limit = {
-      seperator: "offset",
-      value: [
-        { type: "number", value: opts.limit },
-        { type: "number", value: opts.offset },
-      ],
-    };
-  } else if (where?.limit) {
-    ast[0].limit = {
-      seperator: "",
-      value: [{ type: "number", value: where.limit }],
-    };
-  } else if (opts?.limit) {
-    ast[0].limit = {
-      seperator: "",
-      value: [{ type: "number", value: opts.limit }],
-    };
-  }
-  //console.log(ast[0]);
-  //console.log(ast[0].orderby[[0]]);
+    if (where?.limit && where?.offset) {
+      ast[0].limit = {
+        seperator: "offset",
+        value: [
+          { type: "number", value: where.limit },
+          { type: "number", value: where.offset },
+        ],
+      };
+    } else if (opts?.limit && opts?.offset) {
+      ast[0].limit = {
+        seperator: "offset",
+        value: [
+          { type: "number", value: opts.limit },
+          { type: "number", value: opts.offset },
+        ],
+      };
+    } else if (where?.limit) {
+      ast[0].limit = {
+        seperator: "",
+        value: [{ type: "number", value: where.limit }],
+      };
+    } else if (opts?.limit) {
+      ast[0].limit = {
+        seperator: "",
+        value: [{ type: "number", value: opts.limit }],
+      };
+    }
+    //console.log(ast[0]);
+    //console.log(ast[0].orderby[[0]]);
 
-  const orderBy = where?.orderBy || opts?.orderBy;
-  const orderDesc = where?.orderDesc || opts?.orderDesc;
+    const orderBy = where?.orderBy || opts?.orderBy;
+    const orderDesc = where?.orderDesc || opts?.orderDesc;
 
-  if (orderBy) {
-    if (typeof orderBy === "string")
-      ast[0].orderby = [
-        {
-          expr: {
-            type: "column_ref",
-            table: null,
-            column: db.sqlsanitize(orderBy),
-          },
-          type: orderDesc ? "DESC" : "ASC",
-        },
-      ];
-    else if (orderBy.operator) {
-      const { operator, field, target } = orderBy;
-      const fieldCol = (cfg.columns || []).find((c) => c.name === field);
-      const type = getState().types[fieldCol?.type];
-      const op = type?.distance_operators[operator];
-      if (op?.type === "SqlBinOp") {
+    if (orderBy) {
+      if (typeof orderBy === "string")
         ast[0].orderby = [
           {
             expr: {
-              type: "binary_expr",
-              operator: op.name,
-              left: {
-                type: "column_ref",
-                table: null,
-                column: db.sqlsanitize(field),
-              },
-              right: {
-                type: "number",
-                value: "$" + phIndex,
-              },
+              type: "column_ref",
+              table: null,
+              column: db.sqlsanitize(orderBy),
             },
             type: orderDesc ? "DESC" : "ASC",
           },
         ];
-        phIndex += 1;
-        phValues.push(target);
+      else if (orderBy.operator) {
+        const { operator, field, target } = orderBy;
+        const fieldCol = (cfg.columns || []).find((c) => c.name === field);
+        const type = getState().types[fieldCol?.type];
+        const op = type?.distance_operators[operator];
+        if (op?.type === "SqlBinOp") {
+          ast[0].orderby = [
+            {
+              expr: {
+                type: "binary_expr",
+                operator: op.name,
+                left: {
+                  type: "column_ref",
+                  table: null,
+                  column: db.sqlsanitize(field),
+                },
+                right: {
+                  type: "number",
+                  value: "$" + phIndex,
+                },
+              },
+              type: orderDesc ? "DESC" : "ASC",
+            },
+          ];
+          phIndex += 1;
+          phValues.push(target);
+        }
       }
     }
+    sqlQ = parser.sqlify(ast, opt);
   }
   const client = is_sqlite ? db : await db.getClient();
   await client.query(`BEGIN;`);
@@ -339,8 +353,7 @@ const runQuery = async (cfg, where, opts) => {
     await client.query(`SET SESSION CHARACTERISTICS AS TRANSACTION READ ONLY;`);
   }
 
-  const sqlQ = parser.sqlify(ast, opt);
-  console.log({ sqlQ, phValues, opts });
+  //console.log({ sqlQ, phValues, opts });
   const qres = await client.query(sqlQ, phValues);
   qres.query = sqlQ;
   await client.query(`ROLLBACK;`);