@saltcorn/sql 0.5.0 → 0.5.2

package/agent-skill.js

@@ -4,10 +4,12 @@ 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 FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
 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 { features } = require("@saltcorn/data/db/state");
 
 //const { fieldProperties } = require("./helpers");
 
@@ -28,17 +30,22 @@ class SQLQuerySkill {
     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]);
+    if (this.mode === "Preload into system prompt") {
+      (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]);
+        });
+    } else {
+      (this.toolargs || []).forEach((arg) => {
+        phValues.push(row[arg.name]);
       });
-
+    }
     const client = is_sqlite ? db : await db.getClient();
     await client.query(`BEGIN;`);
     if (!is_sqlite) {
@@ -77,23 +84,64 @@ class SQLQuerySkill {
         label: "Mode",
         type: "String",
         required: true,
-        attributes: { options: [/*"Tool",*/ "Preload into system prompt"] },
+        attributes: {
+          options: features.nested_fieldrepeats
+            ? ["Preload into system prompt", "Tool"]
+            : ["Preload into system prompt"],
+        },
+      },
+      {
+        name: "tool_name",
+        label: "Tool name",
+        type: "String",
+        showIf: { mode: "Tool" },
+      },
+      {
+        name: "tool_description",
+        label: "Tool description",
+        type: "String",
+        showIf: { mode: "Tool" },
       },
+
       {
         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",
+          "Refer to query parameters with <code>$1</code>, <code>$2</code> etc",
       },
+      { input_type: "section_header", label: "Query parameters" },
+      new FieldRepeat({
+        name: "toolargs",
+        showIf: { mode: "Tool" },
+        fields: [
+          {
+            name: "name",
+            label: "Name",
+            type: "String",
+          },
+          {
+            name: "description",
+            label: "Description",
+            type: "String",
+          },
+          {
+            name: "argtype",
+            label: "Type",
+            type: "String",
+            required: true,
+            attributes: { options: ["string", "number", "integer", "boolean"] },
+          },
+        ],
+      }),
       {
         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" },
+        showIf: { mode: "Preload into system prompt" },
       },
       {
         name: "add_sys_prompt",
@@ -111,6 +159,38 @@ class SQLQuerySkill {
       },
     ];
   }
+
+  provideTools = () => {
+    if (this.mode === "Preload into system prompt") return null;
+    let properties = {};
+    (this.toolargs || []).forEach((arg) => {
+      properties[arg.name] = {
+        description: arg.description,
+        type: arg.argtype,
+      };
+    });
+    return {
+      type: "function",
+      process: async (row, { req }) => {
+        return await this.runQuery({ triggering_row: row });
+      },
+      /*renderToolCall({ phrase }, { req }) {
+        return div({ class: "border border-primary p-2 m-2" }, phrase);
+      },*/
+      renderToolResponse: async (response, { req }) => {
+        return div({ class: "border border-success p-2 m-2" }, response);
+      },
+      function: {
+        name: this.tool_name,
+        description: this.tool_description,
+        parameters: {
+          type: "object",
+          required: (this.toolargs || []).map((a) => a.name),
+          properties,
+        },
+      },
+    };
+  };
 }
 
 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>`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saltcorn/sql",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Actions and views based on SQL",
   "main": "index.js",
   "dependencies": {

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;`);