@saltcorn/copilot 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Saltcorn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Saltcorn copilot
+
+AI assistant for building Saltcorn applications

package/action-builder.js

@@ -0,0 +1,174 @@
+const Field = require("@saltcorn/data/models/field");
+const Table = require("@saltcorn/data/models/table");
+const Form = require("@saltcorn/data/models/form");
+const View = require("@saltcorn/data/models/view");
+const Trigger = require("@saltcorn/data/models/trigger");
+const db = require("@saltcorn/data/db");
+const Workflow = require("@saltcorn/data/models/workflow");
+const { renderForm } = require("@saltcorn/markup");
+const { div, script, domReady, pre, code } = require("@saltcorn/markup/tags");
+const { getState } = require("@saltcorn/data/db/state");
+const {
+  getCompletion,
+  getPromptFromTemplate,
+  incompleteCfgMsg,
+} = require("./common");
+
+const get_state_fields = () => [];
+
+const getForm = async ({ viewname, body, hasCode }) => {
+  const tables = await Table.find({});
+  const table_triggers = ["Insert", "Update", "Delete", "Validate"];
+
+  const hasChannel = Object.entries(getState().eventTypes)
+    .filter(([k, v]) => v.hasChannel)
+    .map(([k, v]) => k);
+  const fields = [
+    {
+      name: "name",
+      label: "Name",
+      type: "String",
+      required: true,
+      sublabel: "Name of action",
+    },
+    {
+      name: "when_trigger",
+      label: "When",
+      input_type: "select",
+      required: true,
+      options: Trigger.when_options.map((t) => ({ value: t, label: t })),
+      sublabel: "Event type which runs the trigger",
+      help: { topic: "Event types" },
+      attributes: {
+        explainers: {
+          Often: "Every 5 minutes",
+          Never:
+            "Not scheduled but can be run as an action from a button click",
+        },
+      },
+    },
+    {
+      name: "table_id",
+      label: "Table",
+      input_type: "select",
+      options: [...tables.map((t) => ({ value: t.id, label: t.name }))],
+      showIf: { when_trigger: table_triggers },
+      sublabel: "The table for which the trigger condition is checked.",
+    },
+    {
+      name: "channel",
+      label: "Channel",
+      type: "String",
+      sublabel: "Leave blank for all channels",
+      showIf: { when_trigger: hasChannel },
+    },
+    {
+      name: "prompt",
+      label: "Action description",
+      fieldview: "textarea",
+      sublabel: "What would you like this action to do?",
+      type: "String",
+    },
+    ...(hasCode
+      ? [
+          {
+            name: "code",
+            label: "Generated code",
+            fieldview: "textarea",
+            attributes: { mode: "application/javascript" },
+            input_type: "code",
+          },
+        ]
+      : []),
+  ];
+  const form = new Form({
+    action: `/view/${viewname}`,
+    fields,
+    submitLabel: body?.prompt ? "Re-generate code" : "Generate code",
+    additionalButtons: body?.prompt
+      ? [
+          {
+            label: "Save as trigger",
+            onclick: "save_as_action(this)",
+            class: "btn btn-primary",
+            afterSave: true,
+          },
+        ]
+      : undefined,
+  });
+  return form;
+};
+
+const js = (viewname) =>
+  script(`
+function save_as_action(that) {
+  const form = $(that).closest('form');
+  view_post("${viewname}", "save_as_action", $(form).serialize())
+}
+`);
+
+const run = async (table_id, viewname, cfg, state, { res, req }) => {
+  const form = await getForm({ viewname });
+  const cfgMsg = incompleteCfgMsg();
+  if (cfgMsg) return cfgMsg;
+  else return renderForm(form, req.csrfToken());
+};
+
+const runPost = async (
+  table_id,
+  viewname,
+  config,
+  state,
+  body,
+  { req, res }
+) => {
+  const form = await getForm({ viewname, body, hasCode: true });
+  form.validate(body);
+
+  form.hasErrors = false;
+  form.errors = {};
+
+  const fullPrompt = await getPromptFromTemplate(
+    "action-builder.txt",
+    form.values.prompt
+  );
+
+  const completion = await getCompletion("JavaScript", fullPrompt);
+
+  form.values.code = completion;
+  res.sendWrap("Action Builder Copilot", [
+    renderForm(form, req.csrfToken()),
+    js(viewname),
+  ]);
+};
+
+const save_as_action = async (table_id, viewname, config, body, { req }) => {
+  const form = await getForm({ viewname, body, hasCode: true });
+  form.validate(body);
+  if (!form.hasErrors) {
+    const { name, when_trigger, table_id, channel, prompt, code } = form.values;
+    await Trigger.create({
+      name,
+      when_trigger,
+      table_id,
+      channel,
+      description: prompt,
+      action: "run_js_code",
+      configuration: { code },
+    });
+
+    return { json: { success: "ok", notify: `Trigger ${name} created` } };
+  }
+  return { json: { error: "Form incomplete" } };
+};
+
+module.exports = {
+  name: "Action Builder Copilot",
+  display_state_form: false,
+  get_state_fields,
+  tableless: true,
+  singleton: true,
+  run,
+  runPost: runPost,
+  routes: { save_as_action },
+};

package/common.js

@@ -0,0 +1,60 @@
+const axios = require("axios");
+const fsp = require("fs").promises;
+const _ = require("underscore");
+const path = require("path");
+const Field = require("@saltcorn/data/models/field");
+const Table = require("@saltcorn/data/models/table");
+const Form = require("@saltcorn/data/models/form");
+const View = require("@saltcorn/data/models/view");
+const Trigger = require("@saltcorn/data/models/trigger");
+const { getState } = require("@saltcorn/data/db/state");
+
+const getPromptFromTemplate = async (tmplName, userPrompt, extraCtx = {}) => {
+  const tables = await Table.find({});
+  const context = {
+    Table,
+    tables,
+    View,
+    userTable: Table.findOne("users"),
+    scState: getState(),
+    userPrompt,
+    ...extraCtx,
+  };
+  const fp = path.join(__dirname, "prompts", tmplName);
+  const fileBuf = await fsp.readFile(fp);
+  const tmpl = fileBuf.toString();
+  const template = _.template(tmpl, {
+    evaluate: /\{\{#(.+?)\}\}/g,
+    interpolate: /\{\{([^#].+?)\}\}/g,
+  });
+  const prompt = template(context);
+  console.log("Full prompt:\n", prompt);
+  return prompt;
+};
+
+const getCompletion = async (language, prompt) => {
+  return getState().functions.llm_generate.run(prompt, {
+    systemPrompt: `You are a helpful code assistant. Your language of choice is ${language}. Do not include any explanation, just generate the code block itself.`,
+  });
+};
+
+const incompleteCfgMsg = () => {
+  const plugin_cfgs = getState().plugin_cfgs;
+
+  if (
+    !plugin_cfgs["@saltcorn/large-language-model"] &&
+    !plugin_cfgs["large-language-model"]
+  ) {
+    const modName = Object.keys(plugin_cfgs).find((m) =>
+      m.includes("large-language-model")
+    );
+    if (modName)
+      return `LLM module not configured. Please configure <a href="/plugins/configure/${encodeURIComponent(
+        modName
+      )}">here<a> before using copilot.`;
+    else
+      return `LLM module not configured. Please install and configure <a href="/plugins">here<a> before using copilot.`;
+  }
+};
+
+module.exports = { getCompletion, getPromptFromTemplate, incompleteCfgMsg };

package/database-designer.js

@@ -0,0 +1,277 @@
+const Field = require("@saltcorn/data/models/field");
+const Table = require("@saltcorn/data/models/table");
+const Form = require("@saltcorn/data/models/form");
+const View = require("@saltcorn/data/models/view");
+const Trigger = require("@saltcorn/data/models/trigger");
+const { findType } = require("@saltcorn/data/models/discovery");
+const { save_menu_items } = require("@saltcorn/data/models/config");
+const db = require("@saltcorn/data/db");
+const Workflow = require("@saltcorn/data/models/workflow");
+const { renderForm } = require("@saltcorn/markup");
+const { div, script, domReady, pre, code } = require("@saltcorn/markup/tags");
+const { getState } = require("@saltcorn/data/db/state");
+const {
+  getCompletion,
+  getPromptFromTemplate,
+  incompleteCfgMsg,
+} = require("./common");
+const { Parser } = require("node-sql-parser");
+const parser = new Parser();
+const { initial_config_all_fields } = require("@saltcorn/data/plugin-helper");
+
+const get_state_fields = () => [];
+
+const getForm = async ({ viewname, body, hasCode }) => {
+  const fields = [
+    {
+      name: "prompt",
+      label: "Database description",
+      fieldview: "textarea",
+      sublabel: "What would you like to design a database for?",
+      type: "String",
+    },
+
+    ...(hasCode
+      ? [
+          {
+            name: "code",
+            label: "Generated code",
+            fieldview: "textarea",
+            attributes: { mode: "application/javascript" },
+            input_type: "code",
+          },
+          {
+            name: "basic_views",
+            label: "Generate views",
+            sublabel:
+              "Also generate basic views (Show, Edit, List) for the generated tables",
+            type: "Bool",
+          },
+        ]
+      : []),
+  ];
+  const form = new Form({
+    action: `/view/${viewname}`,
+    fields,
+    submitLabel: body?.prompt
+      ? "Re-generate database design"
+      : "Generate database design",
+    additionalButtons: body?.prompt
+      ? [
+          {
+            label: "Save this database permanently",
+            onclick: "save_database(this)",
+            class: "btn btn-primary",
+            afterSave: true,
+          },
+        ]
+      : undefined,
+  });
+  return form;
+};
+
+const js = (viewname) =>
+  script(`
+function save_database(that) {
+  const form = $(that).closest('form');
+  view_post("${viewname}", "save_database", $(form).serialize())
+}
+`);
+
+const run = async (table_id, viewname, cfg, state, { res, req }) => {
+  const form = await getForm({ viewname });
+  const cfgMsg = incompleteCfgMsg();
+  if (cfgMsg) return cfgMsg;
+  else return renderForm(form, req.csrfToken());
+};
+
+const runPost = async (
+  table_id,
+  viewname,
+  config,
+  state,
+  body,
+  { req, res }
+) => {
+  const form = await getForm({ viewname, body, hasCode: true });
+  form.validate(body);
+
+  form.hasErrors = false;
+  form.errors = {};
+
+  const fullPrompt = await getPromptFromTemplate(
+    "database-designer.txt",
+    form.values.prompt
+  );
+  const completion = await getCompletion("SQL", fullPrompt);
+
+  form.values.code = completion;
+  res.sendWrap("Databse Designer Copilot", [
+    renderForm(form, req.csrfToken()),
+    js(viewname),
+  ]);
+};
+
+const moreTypes = {
+  decimal: "Float",
+  varchar: "String",
+};
+
+const save_database = async (table_id, viewname, config, body, { req }) => {
+  const form = await getForm({ viewname, body, hasCode: true });
+  form.validate(body);
+
+  if (!form.hasErrors) {
+    const genTables = [];
+    const { tableList, ast } = parser.parse(form.values.code, {
+      database: "PostgreSQL",
+    });
+    const tables_to_create = [];
+    for (const { type, keyword, create_definitions, table } of ast) {
+      if (type !== "create" || keyword !== "table" || !table?.length) continue;
+      const tblName = table[0].table;
+
+      const fields = [];
+      for (const {
+        column,
+        definition,
+        primary_key,
+        reference_definition,
+      } of create_definitions) {
+        if (primary_key) continue;
+        let type =
+          findType(definition.dataType.toLowerCase()) ||
+          moreTypes[definition.dataType.toLowerCase()];
+        if (reference_definition)
+          type = `Key to ${reference_definition.table[0].table}`;
+
+        fields.push({
+          name: column.column,
+          type,
+        });
+
+        //onsole.log(fld, definition.dataType);
+      }
+      tables_to_create.push({ name: tblName, fields });
+    }
+    for (const table of tables_to_create) await Table.create(table.name);
+
+    for (const tbl of tables_to_create) {
+      const table = Table.findOne({ name: tbl.name });
+
+      for (const field of tbl.fields) {
+        field.table = table;
+        //pick summary field
+        if (field.type === "Key to users") {
+          field.attributes = { summary_field: "email" };
+        } else if (field.type.startsWith("Key to ")) {
+          const reftable_name = field.type.replace("Key to ", "");
+          const reftable = tables_to_create.find(
+            (t) => t.name === reftable_name
+          );
+          const summary_field = reftable.fields.find(
+            (f) => f.type === "String"
+          );
+          if (summary_field)
+            field.attributes = { summary_field: summary_field.name };
+          else field.attributes = { summary_field: "id" };
+        }
+        await Field.create(field);
+      }
+    }
+
+    if (form.values.basic_views)
+      for (const { name } of tables_to_create) {
+        const table = Table.findOne({ name });
+
+        const list = await initial_view(table, "List");
+        const edit = await initial_view(table, "Edit");
+        const show = await initial_view(table, "Show");
+        await View.update(
+          {
+            configuration: {
+              ...list.configuration,
+              columns: [
+                ...list.configuration.columns,
+                {
+                  type: "ViewLink",
+                  view: `Own:Show ${name}`,
+                  view_name: `Show ${name}`,
+                  link_style: "",
+                  view_label: "Show",
+                  header_label: "Show",
+                },
+                {
+                  type: "ViewLink",
+                  view: `Own:Edit ${name}`,
+                  view_name: `Edit ${name}`,
+                  link_style: "",
+                  view_label: "Edit",
+                  header_label: "Edit",
+                },
+                {
+                  type: "Action",
+                  action_name: "Delete",
+                  action_style: "btn-primary",
+                },
+              ],
+              view_to_create: `Edit ${name}`,
+            },
+          },
+          list.id
+        );
+        await View.update(
+          {
+            configuration: {
+              ...edit.configuration,
+              view_when_done: `List ${name}`,
+              destination_type: "View",
+            },
+          },
+          edit.id
+        );
+        await add_to_menu({
+          label: name,
+          type: "View",
+          min_role: 100,
+          viewname: `List ${name}`,
+        });
+      }
+
+    return { json: { success: "ok", notify: `Database created` } };
+  }
+  return { json: { error: "Form incomplete" } };
+};
+const add_to_menu = async (item) => {
+  const current_menu = getState().getConfigCopy("menu_items", []);
+  const existing = current_menu.findIndex((m) => m.label === item.label);
+  if (existing >= 0) current_menu[existing] = item;
+  else current_menu.push(item);
+  await save_menu_items(current_menu);
+};
+const initial_view = async (table, viewtemplate) => {
+  const configuration = await initial_config_all_fields(
+    viewtemplate === "Edit"
+  )({ table_id: table.id });
+  //console.log(configuration);
+  const name = `${viewtemplate} ${table.name}`;
+  const view = await View.create({
+    name,
+    configuration,
+    viewtemplate,
+    table_id: table.id,
+    min_role: 100,
+  });
+  return view;
+};
+
+module.exports = {
+  name: "Database Design Copilot",
+  display_state_form: false,
+  get_state_fields,
+  tableless: true,
+  singleton: true,
+  run,
+  runPost: runPost,
+  routes: { save_database },
+};

package/index.js

@@ -0,0 +1,14 @@
+const Workflow = require("@saltcorn/data/models/workflow");
+const Form = require("@saltcorn/data/models/form");
+
+const configuration_workflow = () =>
+  new Workflow({
+    steps: [],
+  });
+
+module.exports = {
+  sc_plugin_api_version: 1,
+  //configuration_workflow,
+  dependencies: ["@saltcorn/large-language-model"],
+  viewtemplates: [require("./action-builder"), require("./database-designer")],
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@saltcorn/copilot",
+  "version": "0.1.0",
+  "description": "AI assistant for building Saltcorn applications",
+  "main": "index.js",
+  "dependencies": {
+    "@saltcorn/data": "^0.9.0",
+    "axios": "0.16.2",
+    "underscore": "1.13.6",
+    "node-sql-parser": "4.15.0"
+  },
+  "author": "Tom Nielsen",
+  "license": "MIT",
+  "repository": "github:saltcorn/copilot",
+  "eslintConfig": {
+    "extends": "eslint:recommended",
+    "parserOptions": {
+      "ecmaVersion": 2020
+    },
+    "env": {
+      "node": true,
+      "es6": true
+    },
+    "rules": {
+      "no-unused-vars": "off",
+      "no-case-declarations": "off",
+      "no-empty": "warn",
+      "no-fallthrough": "warn"
+    }
+  }
+}

package/prompts/action-builder.txt

@@ -0,0 +1,307 @@
+Your code can can manipulate rows in the database, manipulate files, interact 
+with remote APIs, or issue directives for the user's display.
+
+Your code can use await at the top level, and should do so whenever calling 
+database queries or other aynchronous code (see example below)
+
+The variable `table` is the associated table (if any; note lowercase). If you want to access a different table,
+use the `Table` variable (note uppercase) to access the Table class of table.
+
+Example:
+
+await table.insertRow({name: "Alex", age: 43})
+const otherTable = Table.findOne({name: "Orders"})
+await otherTable.deleteRows({id: order})
+
+
+You can use the Table class to access database tables. Use this to create or delete tables and 
+their properties, or to query or change table rows.
+
+To query, update, insert or delete rows in an existing table, first you should find the 
+table object with findOne.
+
+Example: 
+
+Table.findOne({name: "Customers"}) // find the table with name "Customers"
+Table.findOne("Customers") // find the table with name "Customers" (shortcut)
+Table.findOne({ id: 5 }) // find the table with id=5
+Table.findOne(5) // find the table with id=5 (shortcut)
+
+Table.findOne is synchronous (no need to await), But the functions that query and manipulate 
+(such as insertRow, getRows, updateRow, deleteRows) rows are mostly asyncronous, so you can 
+put the await in front of the whole expression.
+
+Example:
+To count the number of rows in the customer table:
+
+const nrows = await Table.findOne("Customers").countRows({})
+
+Querying table rows
+
+There are several methods you can use to retrieve rows in the database:
+
+countRows: Count the number of rows in db table. The argument is a where-expression with conditions the
+counted rows should match. countRows returns the number of matching rows wrapped in a promise.
+
+countRows(where?): Promise<number>
+Count amount of rows in db table
+
+Parameters
+Optional where: Where
+Returns Promise<number>
+
+Example of using countRows: 
+const bookTable = Table.findOne({name: "books"})
+ 
+// Count the total number of rows in the books table
+const totalNumberOfBooks = await bookTable.countRows({})
+
+// Count the number of books where the cover_color field has the value is "Red"
+const numberOfRedBooks = await bookTable.countRows({cover_color: "Red"})
+
+// Count number of books with more than 500 pages
+const numberOfLongBooks = await bookTable.countRows({pages: {gt: 500}})
+
+getRows: Get all matching rows from the table in the database.
+
+The arguments are the same as for getRow. The first argument is where-expression
+with the conditions to match, and the second argument is an optional object and 
+allows you to set ordering and limit options. Keywords that can be used in the 
+second argument are orderBy, orderDesc, limit and offset.
+
+getRows will return an array of rows matching the where-expression in the first 
+argument, wrapped in a Promise (use await to read the array).
+
+
+getRows(where?, selopts?): Promise<Row[]>
+Get rows from Table in db
+
+Parameters
+where: Where = {}
+selopts: SelectOptions & ForUserRequest = {}
+Returns Promise<Row[]>
+
+Example of using getRows:
+
+const bookTable = Table.findOne({name: "books"})
+
+// get the rows in the book table with author = "Henrik Pontoppidan"
+const myBooks = await bookTable.getRows({author: "Henrik Pontoppidan"})
+
+// get the 3 most recent books written by "Henrik Pontoppidan" with more that 500 pages
+const myBooks = await bookTable.getRows({author: "Henrik Pontoppidan", pages: {gt: 500}}, {orderBy: "published", orderDesc: true})
+
+getRow: Get one row from the table in the database. The matching row will be returned in a promise - 
+use await to read the value. If no matching rule can be found, null will be returned. If more than one
+ row matches, the first found row will be returned.
+
+The first argument to get row is a where-expression With the conditions the returned row should match.
+
+The second document is optional and is an object that can modify the search. This is mainly useful in 
+case there is more than one matching row for the where-expression in the first argument and you want to 
+give an explicit order. For example, use {orderBy: "name"} as the second argument to pick the first 
+row by the name field, ordered ascending. {orderBy: "name", orderDesc: true} to order by name, descending
+
+This is however rare and usually getRow is run with a single argument of a Where expression that uniquely 
+determines the row to return, if it exisits.
+
+getRow(where?, selopts?): Promise<null | Row>
+Get one row from table in db
+
+Parameters
+where: Where = {}
+selopts: SelectOptions & ForUserRequest = {}
+Returns Promise<null | Row>
+
+Example of using getRow:
+const bookTable = Table.findOne({name: "books"})
+
+// get the row in the book table with id = 5
+const myBook = await bookTable.getRow({id: 5})
+
+// get the row for the last book published by Leo Tolstoy
+const myBook = await bookTable.getRow({author: "Leo Tolstoy"}, {orderBy: "published", orderDesc: true})
+
+getJoinedRows: To retrieve rows together with joinfields and aggregations
+
+getJoinedRows(opts?): Promise<Row[]>
+Get rows along with joined and aggregated fields. The argument to getJoinedRows is an object with several different possible fields, all of which are optional
+
+where: A Where expression indicating the criterion to match
+joinFields: An object with the joinfields to retrieve
+aggregations: An object with the aggregations to retrieve
+orderBy: A string with the name of the field to order by
+orderDesc: If true, descending order
+limit: A number with the maximum number of rows to retrieve
+offset: The number of rows to skip in the result before returning rows
+Parameters
+Optional opts: any = {}
+Returns Promise<Row[]>
+
+Example of using getJoinedRows: 
+
+const patients = Table.findOne({ name: "patients" });
+const patients_rows = await patients.getJoinedRows({
+     where: { age: { gt: 65 } },
+     orderBy: "id",
+     aggregations: {
+       avg_temp: {
+         table: "readings",
+         ref: "patient_id",
+         field: "temperature",
+         aggregate: "avg",
+      },
+     },
+     joinFields: {
+       pages: { ref: "favbook", target: "pages" },
+       author: { ref: "favbook", target: "author" },
+     },
+});
+
+These functions all take "Where expressions" which are JavaScript objects describing 
+the criterion to match to. Some examples:
+
+{ name: "Jim" }: Match all rows with name="Jim"
+{ name: { ilike: "im"} }: Match all rows where name contains "im" (case insensitive)
+{ name: /im/ }: Match all rows with name matching regular expression "im"
+{ age: { lt: 18 } }: Match all rows with age<18
+{ age: { lt: 18, equal: true } }: Match all rows with age<=18
+{ age: { gt: 18, lt: 65} }: Match all rows with 18<age<65
+{ name: { or: ["Harry", "Sally"] } }: Match all rows with name="Harry" or "Sally"
+{ or: [{ name: "Joe"}, { age: 37 }] }: Match all rows with name="Joe" or age=37
+{ not: { id: 5 } }: All rows except id=5
+{ id: { in: [1, 2, 3] } }: Rows with id 1, 2, or 3
+
+There are two nearly identical functions for updating rows depending on how you want failures treated
+
+updateRow Update a row in the database table, throws an exception if update is invalid
+
+updateRow(v_in, id, user?, noTrigger?, resultCollector?, restore_of_version?, syncTimestamp?): Promise<string | void>
+Update row
+
+Parameters
+v_in: any. columns with values to update
+
+id: number. id value, table primary key
+
+Optional user: Row
+Optional noTrigger: boolean
+Optional resultCollector: object
+Optional restore_of_version: any
+Optional syncTimestamp: Date
+
+Example of using updateRow: 
+
+const bookTable = Table.findOne({name: "books"})
+
+// get the row in the book table for Moby Dick
+const moby_dick = await bookTable.getRow({title: "Moby Dick"})
+
+// Update the read field to true and the rating field to 5 in the retrieved row.
+await bookTable.updateRow({read: true, rating: 5}, moby_dick.id)
+
+// if you want to update more than one row, you must first retrieve all the rows and 
+// then update them individually
+
+const allBooks = await bookTable.getRows()
+for(const book of allBooks) {
+  await bookTable.updateRow({price: book.price*0.8}, book.id)
+}
+
+tryUpdateRow Update a row, return an error message if update is invalid
+
+There are two nearly identical functions for inserting a new row depending on how you want failures treated
+
+insertRow insert a row, throws an exception if it is invalid
+insertRow(v_in, user?, resultCollector?, noTrigger?, syncTimestamp?): Promise<any>
+Insert row into the table. By passing in the user as the second argument, tt will check write rights. If a user object is not supplied, the insert goes ahead without checking write permissions.
+
+Returns the primary key value of the inserted row.
+
+This will throw an exception if the row does not conform to the table constraints. If you would like to insert a row with a function that can return an error message, use tryInsertRow instead.
+
+Parameters
+v_in: Row
+Optional user: Row
+Optional resultCollector: object
+Optional noTrigger: boolean
+Optional syncTimestamp: Date
+Returns Promise<any>
+
+Example of using insertRow: 
+await Table.findOne("People").insertRow({ name: "Jim", age: 35 })
+
+tryInsertRow insert a row, return an error message if it is invalid
+
+Use deleteRows to delete any number (zero, one or many) of rows matching a criterion. It uses the same where expression as the functions for querying rows
+deleteRows(where, user?, noTrigger?): Promise<void>
+Delete rows from table
+
+Parameters
+where: Where
+condition
+
+Optional user: Row
+optional user, if null then no authorization will be checked
+
+Optional noTrigger: boolean
+Returns Promise<void>
+
+The following tables are present in the database:
+
+{{# for (const table of tables) { }}
+{{ table.name }} table with name = "{{ table.name }}" which has the following fields:
+{{# for (const field of table.fields) { }} - {{ field.name }} of type {{ field.pretty_type }}
+{{# } }}
+{{# } }}
+
+The code may run in a context of a single row. In that case the variable called `row` 
+can be used to access its data as a JavaScript object. The primary key value for the current row
+can be accessed with row.id
+
+In addition to `table` and `Table`, you can use other functions/variables:
+
+sleep: A small utility function to sleep for certain number of milliseconds. Use this with await
+
+Example: `await sleep(1000)`
+
+`fetch` and `fetchJSON`: Use these to make HTTP API calls. `fetch` is the standard JavaScript `fetch` (provided by 
+[node-fetch](https://www.npmjs.com/package/node-fetch#common-usage)). `fetchJSON` performs a fetch 
+and then reads its reponse to JSON
+
+Example: 
+
+const response = await fetch('https://api.github.com/users/github');
+const data = await response.json();
+
+which is the same as
+
+const data = await fetchJSON('https://api.github.com/users/github');
+
+The logged-in user Is available in the `user` variable as a JavaScript object. The primary key for the 
+logged-in user is accessed as `user.id` and their email address as `user.email`.
+
+Your code can with its return value give directives to the current page. 
+Valid return values are:
+
+notify: Send a pop-up notification indicating success to the user. Example: return { notify: "Order completed!" }
+
+error: Send a pop-up notification indicating error to the user. Example: return { error: "Invalid command!" }
+
+goto: Navigate to a different URL. Example: return { goto: "https://saltcorn.com" }
+
+reload_page: Request a page reload with the existing URL. Example: return { reload_page: true }
+
+popup: Open a URL in a popup. Example: return { popup: `/view/Orders?id=${parent}`}
+
+set_fields: If triggered from an edit view, set fields dynamically in the form. The 
+value should be an object with keys that are field variable names. Example:
+
+return { set_fields: {
+    zidentifier: `${name.toUpperCase()}-${id}`
+  }
+}
+
+Write the JavaScript code to implement the following functionality:
+
+{{ userPrompt }}

package/prompts/database-designer.txt

@@ -0,0 +1,18 @@
+Your task is to design a database schema for the following application:
+
+{{ userPrompt }}
+
+Do not use natural or composite primary keys. Every table should have an auto incrementing primary key field called "id". 
+
+Your database currently already contains a table for users with the following definitions.
+
+CREATE TABLE users (
+{{# userTable.fields.forEach((field,ix)=>{ }} {{ field.name }} {{field.primary_key && field.type.name==="Integer"? "SERIAL PRIMARY KEY":field.sql_type}}{{ix===userTable.fields.length-1 ? '':',' }}
+{{# }) }});
+
+Do not include the users table in you schema, but you can include foreign key fields referencing the id field of the users table.
+
+Write the SQL to define the tables for PostgreSQL for this application:
+
+{{ userPrompt }}
+