@openfn/language-mysql 3.0.6 → 4.0.1

package/ast.json

@@ -13,6 +13,11 @@
             "title": "example",
             "description": "sql(state => `select * from ${state.data.tableName};`, { writeSql: true })"
           },
+          {
+            "title": "example",
+            "description": "sql(state => `select * from ?? where id = ?;`, {\n  values: state => [state.data.tableName, state.data.id],\n});",
+            "caption": "Prepared statements"
+          },
           {
             "title": "function",
             "description": null,
@@ -25,59 +30,28 @@
           },
           {
             "title": "param",
-            "description": "The SQL query as a string or a function that returns a string using state.",
+            "description": "The sql query string.",
             "type": {
-              "type": "UnionType",
-              "elements": [
-                {
-                  "type": "NameExpression",
-                  "name": "string"
-                },
-                {
-                  "type": "NameExpression",
-                  "name": "function"
-                }
-              ]
+              "type": "NameExpression",
+              "name": "string"
             },
             "name": "sqlQuery"
           },
           {
             "title": "param",
-            "description": "Optional options argument.",
+            "description": " The sql query options.",
             "type": {
               "type": "OptionalType",
               "expression": {
                 "type": "NameExpression",
-                "name": "object"
+                "name": "sqlOptions"
               }
             },
             "name": "options"
           },
           {
-            "title": "param",
-            "description": "If true, logs the generated SQL statement. Defaults to false.",
-            "type": {
-              "type": "OptionalType",
-              "expression": {
-                "type": "NameExpression",
-                "name": "boolean"
-              }
-            },
-            "name": "options.writeSql",
-            "default": "false"
-          },
-          {
-            "title": "param",
-            "description": "If false, does not execute the SQL, just logs it and adds to state.queries. Defaults to true.",
-            "type": {
-              "type": "OptionalType",
-              "expression": {
-                "type": "NameExpression",
-                "name": "boolean"
-              }
-            },
-            "name": "options.execute",
-            "default": "true"
+            "title": "state",
+            "description": "{MySQLState}"
           },
           {
             "title": "returns",
@@ -89,7 +63,7 @@
           }
         ]
       },
-      "valid": false
+      "valid": true
     },
     {
       "name": "insert",
@@ -102,8 +76,8 @@
         "tags": [
           {
             "title": "example",
-            "description": "insert(\"users\", { name: (state) => state.data.name });",
-            "caption": "Insert a record into the `users` table"
+            "description": "insert(\"users\", { name: \"one\", email: \"one@openfn.org\" });",
+            "caption": "Insert a record into a table"
           },
           {
             "title": "function",
@@ -133,6 +107,10 @@
             },
             "name": "fields"
           },
+          {
+            "title": "state",
+            "description": "{MySQLState}"
+          },
           {
             "title": "returns",
             "description": null,
@@ -156,8 +134,8 @@
         "tags": [
           {
             "title": "example",
-            "description": "upsert(\"table\", { name: (state) => state.data.name });",
-            "caption": "Upsert a record"
+            "description": "upsert(\"users\", { name: \"Tuchi Dev\" });",
+            "caption": "Upsert a record into a table"
           },
           {
             "title": "function",
@@ -187,6 +165,10 @@
             },
             "name": "fields"
           },
+          {
+            "title": "state",
+            "description": "{MySQLState}"
+          },
           {
             "title": "returns",
             "description": null,
@@ -215,8 +197,8 @@
           },
           {
             "title": "example",
-            "description": "upsertMany(\n  'users', // the DB table\n  [\n    { name: 'one', email: 'one@openfn.org' },\n    { name: 'two', email: 'two@openfn.org' },\n  ]\n)",
-            "caption": "Upsert multiple records"
+            "description": "upsertMany(\n  \"users\", // the DB table\n  [\n    { name: \"one\", email: \"one@openfn.org\" },\n    { name: \"two\", email: \"two@openfn.org\" },\n  ]\n);",
+            "caption": "Upsert multiple records into a table"
           },
           {
             "title": "function",
@@ -239,13 +221,17 @@
           },
           {
             "title": "param",
-            "description": "An array of objects or a function that returns an array",
+            "description": "An array of objects fields",
             "type": {
               "type": "NameExpression",
               "name": "array"
             },
             "name": "data"
           },
+          {
+            "title": "state",
+            "description": "{MySQLState}"
+          },
           {
             "title": "returns",
             "description": null,
@@ -929,6 +915,59 @@
       },
       "valid": false
     },
+    {
+      "name": "assert",
+      "params": [
+        "expression",
+        "errorMessage"
+      ],
+      "docs": {
+        "description": "Asserts the given expression or function resolves to `true`, or else throws an exception. Optionally accepts and error message.",
+        "tags": [
+          {
+            "title": "public",
+            "description": null,
+            "type": null
+          },
+          {
+            "title": "function",
+            "description": null,
+            "name": null
+          },
+          {
+            "title": "example",
+            "description": "assert('a' === 'b', '\"a\" is not equal to \"b\"')"
+          },
+          {
+            "title": "param",
+            "description": "The expression or function to be evaluated.",
+            "type": {
+              "type": "NameExpression",
+              "name": "any"
+            },
+            "name": "expression"
+          },
+          {
+            "title": "param",
+            "description": "The error message thrown in case of a failed state.",
+            "type": {
+              "type": "NameExpression",
+              "name": "string"
+            },
+            "name": "errorMessage"
+          },
+          {
+            "title": "returns",
+            "description": null,
+            "type": {
+              "type": "NameExpression",
+              "name": "operation"
+            }
+          }
+        ]
+      },
+      "valid": true
+    },
     {
       "name": "as",
       "params": [

package/dist/index.cjs

@@ -28,6 +28,7 @@ __export(src_exports, {
   alterState: () => import_language_common2.alterState,
   arrayToString: () => import_language_common2.arrayToString,
   as: () => import_language_common2.as,
+  assert: () => import_language_common2.assert,
   combine: () => import_language_common2.combine,
   cursor: () => import_language_common2.cursor,
   dataPath: () => import_language_common2.dataPath,
@@ -43,6 +44,7 @@ __export(src_exports, {
   insert: () => insert,
   lastReferenceValue: () => import_language_common2.lastReferenceValue,
   merge: () => import_language_common2.merge,
+  setMockConnection: () => setMockConnection,
   sourceValue: () => import_language_common2.sourceValue,
   sql: () => sql,
   upsert: () => upsert,
@@ -56,6 +58,7 @@ __export(Adaptor_exports, {
   alterState: () => import_language_common2.alterState,
   arrayToString: () => import_language_common2.arrayToString,
   as: () => import_language_common2.as,
+  assert: () => import_language_common2.assert,
   combine: () => import_language_common2.combine,
   cursor: () => import_language_common2.cursor,
   dataPath: () => import_language_common2.dataPath,
@@ -70,6 +73,7 @@ __export(Adaptor_exports, {
   insert: () => insert,
   lastReferenceValue: () => import_language_common2.lastReferenceValue,
   merge: () => import_language_common2.merge,
+  setMockConnection: () => setMockConnection,
   sourceValue: () => import_language_common2.sourceValue,
   sql: () => sql,
   upsert: () => upsert,
@@ -77,175 +81,187 @@ __export(Adaptor_exports, {
 });
 var import_language_common = require("@openfn/language-common");
 var import_util = require("@openfn/language-common/util");
-var import_mysql = __toESM(require("mysql"), 1);
-var import_squel = __toESM(require("squel"), 1);
+var import_promise = __toESM(require("mysql2/promise"), 1);
+var import_knex = __toESM(require("knex"), 1);
 var import_language_common2 = require("@openfn/language-common");
-function sql(sqlQuery, options = {}) {
+var connection;
+var knexInstance = (0, import_knex.default)({ client: "mysql2" });
+async function connect(state) {
+  if (connection) {
+    return state;
+  }
+  const { host, port, database, password, user } = state.configuration || {};
+  try {
+    connection = await import_promise.default.createConnection({
+      host,
+      user,
+      password,
+      database,
+      port
+    });
+    console.log("Connected to database...");
+  } catch (error) {
+    console.log(error);
+    throw new Error("Unable to connect to database.");
+  }
+  return state;
+}
+async function disconnect(state) {
+  if (connection) {
+    await connection.end();
+    console.log("Disconected from database...");
+    connection = null;
+  }
+  knexInstance.destroy();
+  return state;
+}
+function formatFields(fields2) {
+  if (!fields2)
+    return void 0;
+  return fields2.map((field2) => ({
+    name: field2.name,
+    type: field2.type,
+    characterSet: field2.characterSet,
+    table: field2.orgTable,
+    schema: field2.schema,
+    length: field2.columnLength,
+    decimals: field2.decimals,
+    flags: field2.flags,
+    encoding: field2.encoding
+  }));
+}
+function setMockConnection(mockConnection) {
+  connection = mockConnection;
+}
+function execute(...operations) {
+  const initialState = {
+    queries: []
+  };
   return (state) => {
-    const { connection } = state;
+    return (0, import_language_common.execute)(
+      connect,
+      ...operations,
+      disconnect
+    )({ ...initialState, ...state });
+  };
+}
+function sql(sqlQuery, options = {}) {
+  return async (state) => {
     const [resolvedSqlQuery, resolvedOptions] = (0, import_util.expandReferences)(
       state,
       sqlQuery,
       options
     );
-    const { writeSql = false, execute: execute2 = true } = resolvedOptions;
+    const { writeSql = false, execute: execute2 = true, values } = resolvedOptions;
     if (writeSql) {
       console.log("Prepared SQL:", resolvedSqlQuery);
+      if (values) {
+        state.queries.push({ sql: resolvedSqlQuery, values });
+      } else {
+        state.queries.push(resolvedSqlQuery);
+      }
     }
     if (!execute2) {
+      console.log("Execution skipped, execute is false.");
       return {
         ...state,
-        queries: [...state.queries || [], resolvedSqlQuery]
+        queries: [...state.queries, resolvedSqlQuery]
       };
     }
-    return new Promise((resolve, reject) => {
-      connection.query(resolvedSqlQuery, (err, results, fields2) => {
-        if (err) {
-          console.log("Error executing query. Disconnecting from database.");
-          connection.end();
-          return reject(err);
-        }
-        resolve({ ...state, response: { body: results, fields: fields2 } });
+    try {
+      const [result, fields2] = await connection.execute(
+        resolvedSqlQuery,
+        values
+      );
+      console.log("Query executed successfully.");
+      return (0, import_language_common.composeNextState)(state, {
+        result,
+        fields: formatFields(fields2)
       });
-    });
-  };
-}
-function execute(...operations) {
-  const initialState = {
-    references: [],
-    data: null
-  };
-  return (state) => {
-    return (0, import_language_common.execute)(
-      connect,
-      ...operations,
-      disconnect,
-      cleanupState
-    )({ ...initialState, ...state });
+    } catch (err) {
+      console.log("Error executing query.");
+      throw err;
+    }
   };
 }
-function connect(state) {
-  const { host, port, database, password, user } = state.configuration;
-  var connection = import_mysql.default.createConnection({
-    host,
-    user,
-    password,
-    database,
-    port
-  });
-  connection.connect();
-  console.log(`Preparing to query "` + database + `"...`);
-  return { ...state, connection };
-}
-function disconnect(state) {
-  state.connection.end();
-  return state;
-}
-function cleanupState(state) {
-  delete state.connection;
-  return state;
-}
 function insert(table, fields2) {
-  return (state) => {
-    let { connection } = state;
-    const [valuesObj] = (0, import_util.expandReferences)(state, fields2);
-    const squelMysql = import_squel.default.useFlavour("mysql");
-    var sqlParams = squelMysql.insert({
-      autoQuoteFieldNames: true
-    }).into(table).setFields(valuesObj).toParam();
-    const sql2 = sqlParams.text;
-    const inserts = sqlParams.values;
-    const sqlString = import_mysql.default.format(sql2, inserts);
-    console.log(`Executing MySQL query: ${sqlString}`);
-    return new Promise((resolve, reject) => {
-      connection.query(sqlString, function(err, results, fields3) {
-        if (err) {
-          reject(err);
-          console.log("There is an error. Disconnecting from database.");
-          connection.end();
-        } else {
-          console.log("Success...");
-          console.log(results);
-          console.log(fields3);
-          resolve(results);
-        }
+  return async (state) => {
+    const [resolvedTable, resolvedFields] = (0, import_util.expandReferences)(
+      state,
+      table,
+      fields2
+    );
+    const keys = Object.keys(resolvedFields);
+    const placeholders = keys.map(() => "?").join(", ");
+    const columns = keys.map(() => "??").join(", ");
+    const sqlString = import_promise.default.format(
+      `INSERT INTO ?? (${columns}) VALUES (${placeholders})`,
+      [resolvedTable, ...keys]
+    );
+    try {
+      const [result, fields3] = await connection.execute(
+        sqlString,
+        Object.values(resolvedFields)
+      );
+      console.log("Success...");
+      return (0, import_language_common.composeNextState)(state, {
+        result,
+        fields: formatFields(fields3)
       });
-    }).then((data) => {
-      const nextState = { ...state, response: { body: data } };
-      return nextState;
-    });
+    } catch (err) {
+      console.log("Error inserting record.");
+      throw err;
+    }
   };
 }
 function upsert(table, fields2) {
-  return (state) => {
-    let { connection } = state;
-    const [valuesObj] = (0, import_util.expandReferences)(state, fields2);
-    const squelMysql = import_squel.default.useFlavour("mysql");
-    var insertParams = squelMysql.insert({
-      autoQuoteFieldNames: true
-    }).into(table).setFields(valuesObj).toParam();
-    var sql2 = insertParams.text;
-    var inserts = insertParams.values;
-    const insertString = import_mysql.default.format(sql2, inserts);
-    var updateParams = squelMysql.update({
-      autoQuoteFieldNames: true
-    }).table("").setFields(valuesObj).toParam();
-    var sql2 = updateParams.text;
-    var inserts = updateParams.values;
-    const updateString = import_mysql.default.format(sql2, inserts);
-    const upsertString = insertString + ` ON DUPLICATE KEY UPDATE ` + updateString.slice(10);
+  return async (state) => {
+    const [resolvedTable, resolvedFields] = (0, import_util.expandReferences)(
+      state,
+      table,
+      fields2
+    );
+    const insertQuery = knexInstance(resolvedTable).insert(resolvedFields);
+    const insertString = insertQuery.toString();
+    const updateParts = Object.keys(resolvedFields).map(
+      (key) => `${knexInstance.ref(key)} = VALUES(${knexInstance.ref(key)})`
+    );
+    const updateClause = updateParts.join(", ");
+    const upsertString = `${insertString} ON DUPLICATE KEY UPDATE ${updateClause}`;
     console.log("Executing MySQL query: " + upsertString);
-    return new Promise((resolve, reject) => {
-      connection.query(upsertString, function(err, results, fields3) {
-        if (err) {
-          reject(err);
-          console.log("That's an error. Disconnecting from database.");
-          connection.end();
-        } else {
-          console.log("Success...");
-          console.log(results);
-          console.log(fields3);
-          resolve(results);
-        }
-      });
-    }).then((data) => {
-      const nextState = { ...state, response: { body: data } };
-      return nextState;
-    });
+    try {
+      const [result, fields3] = await connection.execute(upsertString);
+      console.log("Success...");
+      return (0, import_language_common.composeNextState)(state, { result, fields: formatFields(fields3) });
+    } catch (err) {
+      console.log("That's an error.");
+      throw err;
+    }
   };
 }
 function upsertMany(table, data) {
-  return function(state) {
-    return new Promise(function(resolve, reject) {
-      const [rows] = (0, import_util.expandReferences)(state, data);
-      if (!rows || rows.length === 0) {
-        console.log("No records provided; skipping upsert.");
-        resolve(state);
-      }
-      const squelMysql = import_squel.default.useFlavour("mysql");
-      const columns = Object.keys(rows[0]);
-      let upsertSql = squelMysql.insert().into(table).setFieldsRows(rows);
-      columns.map((c) => {
-        upsertSql = upsertSql.onDupUpdate(`${c}=values(${c})`);
-      });
-      const upsertString = upsertSql.toString();
-      let { connection } = state;
-      connection.query(upsertString, function(err, results, fields2) {
-        if (err) {
-          reject(err);
-          console.log("That's an error. Disconnecting from database.");
-          connection.end();
-        } else {
-          console.log("Success...");
-          console.log(results);
-          console.log(fields2);
-          resolve(results);
-        }
-      });
-    }).then(function(data2) {
-      const nextState = { ...state, response: { body: data2 } };
-      return nextState;
-    });
+  return async (state) => {
+    const [resolvedTable, resolvedData] = (0, import_util.expandReferences)(state, table, data);
+    if (!resolvedData || resolvedData.length === 0) {
+      console.log("No records provided; skipping upsert.");
+      return state;
+    }
+    const columns = Object.keys(resolvedData[0]);
+    const insertQuery = knexInstance(resolvedTable).insert(resolvedData);
+    const insertString = insertQuery.toString();
+    const updateParts = columns.map(
+      (c) => `${knexInstance.ref(c)} = VALUES(${knexInstance.ref(c)})`
+    );
+    const updateClause = updateParts.join(", ");
+    const upsertString = `${insertString} ON DUPLICATE KEY UPDATE ${updateClause}`;
+    try {
+      const [result, fields2] = await connection.execute(upsertString);
+      console.log("Success...");
+      return (0, import_language_common.composeNextState)(state, { result, fields: formatFields(fields2) });
+    } catch (err) {
+      console.log("That's an error.");
+      throw err;
+    }
   };
 }
 
@@ -256,6 +272,7 @@ var src_default = Adaptor_exports;
   alterState,
   arrayToString,
   as,
+  assert,
   combine,
   cursor,
   dataPath,
@@ -270,6 +287,7 @@ var src_default = Adaptor_exports;
   insert,
   lastReferenceValue,
   merge,
+  setMockConnection,
   sourceValue,
   sql,
   upsert,

package/dist/index.js

@@ -10,6 +10,7 @@ __export(Adaptor_exports, {
   alterState: () => alterState,
   arrayToString: () => arrayToString,
   as: () => as,
+  assert: () => assert,
   combine: () => combine,
   cursor: () => cursor,
   dataPath: () => dataPath,
@@ -24,15 +25,19 @@ __export(Adaptor_exports, {
   insert: () => insert,
   lastReferenceValue: () => lastReferenceValue,
   merge: () => merge,
+  setMockConnection: () => setMockConnection,
   sourceValue: () => sourceValue,
   sql: () => sql,
   upsert: () => upsert,
   upsertMany: () => upsertMany
 });
-import { execute as commonExecute } from "@openfn/language-common";
+import {
+  execute as commonExecute,
+  composeNextState
+} from "@openfn/language-common";
 import { expandReferences } from "@openfn/language-common/util";
-import mysql from "mysql";
-import squel from "squel";
+import mysql from "mysql2/promise";
+import knex from "knex";
 import {
   fn,
   fnIf,
@@ -40,6 +45,7 @@ import {
   merge,
   field,
   fields,
+  assert,
   cursor,
   dateFns,
   combine,
@@ -51,172 +57,184 @@ import {
   lastReferenceValue,
   as
 } from "@openfn/language-common";
-function sql(sqlQuery, options = {}) {
+var connection;
+var knexInstance = knex({ client: "mysql2" });
+async function connect(state) {
+  if (connection) {
+    return state;
+  }
+  const { host, port, database, password, user } = state.configuration || {};
+  try {
+    connection = await mysql.createConnection({
+      host,
+      user,
+      password,
+      database,
+      port
+    });
+    console.log("Connected to database...");
+  } catch (error) {
+    console.log(error);
+    throw new Error("Unable to connect to database.");
+  }
+  return state;
+}
+async function disconnect(state) {
+  if (connection) {
+    await connection.end();
+    console.log("Disconected from database...");
+    connection = null;
+  }
+  knexInstance.destroy();
+  return state;
+}
+function formatFields(fields2) {
+  if (!fields2)
+    return void 0;
+  return fields2.map((field2) => ({
+    name: field2.name,
+    type: field2.type,
+    characterSet: field2.characterSet,
+    table: field2.orgTable,
+    schema: field2.schema,
+    length: field2.columnLength,
+    decimals: field2.decimals,
+    flags: field2.flags,
+    encoding: field2.encoding
+  }));
+}
+function setMockConnection(mockConnection) {
+  connection = mockConnection;
+}
+function execute(...operations) {
+  const initialState = {
+    queries: []
+  };
   return (state) => {
-    const { connection } = state;
+    return commonExecute(
+      connect,
+      ...operations,
+      disconnect
+    )({ ...initialState, ...state });
+  };
+}
+function sql(sqlQuery, options = {}) {
+  return async (state) => {
     const [resolvedSqlQuery, resolvedOptions] = expandReferences(
       state,
       sqlQuery,
       options
     );
-    const { writeSql = false, execute: execute2 = true } = resolvedOptions;
+    const { writeSql = false, execute: execute2 = true, values } = resolvedOptions;
     if (writeSql) {
       console.log("Prepared SQL:", resolvedSqlQuery);
+      if (values) {
+        state.queries.push({ sql: resolvedSqlQuery, values });
+      } else {
+        state.queries.push(resolvedSqlQuery);
+      }
     }
     if (!execute2) {
+      console.log("Execution skipped, execute is false.");
       return {
         ...state,
-        queries: [...state.queries || [], resolvedSqlQuery]
+        queries: [...state.queries, resolvedSqlQuery]
       };
     }
-    return new Promise((resolve, reject) => {
-      connection.query(resolvedSqlQuery, (err, results, fields2) => {
-        if (err) {
-          console.log("Error executing query. Disconnecting from database.");
-          connection.end();
-          return reject(err);
-        }
-        resolve({ ...state, response: { body: results, fields: fields2 } });
+    try {
+      const [result, fields2] = await connection.execute(
+        resolvedSqlQuery,
+        values
+      );
+      console.log("Query executed successfully.");
+      return composeNextState(state, {
+        result,
+        fields: formatFields(fields2)
       });
-    });
-  };
-}
-function execute(...operations) {
-  const initialState = {
-    references: [],
-    data: null
-  };
-  return (state) => {
-    return commonExecute(
-      connect,
-      ...operations,
-      disconnect,
-      cleanupState
-    )({ ...initialState, ...state });
+    } catch (err) {
+      console.log("Error executing query.");
+      throw err;
+    }
   };
 }
-function connect(state) {
-  const { host, port, database, password, user } = state.configuration;
-  var connection = mysql.createConnection({
-    host,
-    user,
-    password,
-    database,
-    port
-  });
-  connection.connect();
-  console.log(`Preparing to query "` + database + `"...`);
-  return { ...state, connection };
-}
-function disconnect(state) {
-  state.connection.end();
-  return state;
-}
-function cleanupState(state) {
-  delete state.connection;
-  return state;
-}
 function insert(table, fields2) {
-  return (state) => {
-    let { connection } = state;
-    const [valuesObj] = expandReferences(state, fields2);
-    const squelMysql = squel.useFlavour("mysql");
-    var sqlParams = squelMysql.insert({
-      autoQuoteFieldNames: true
-    }).into(table).setFields(valuesObj).toParam();
-    const sql2 = sqlParams.text;
-    const inserts = sqlParams.values;
-    const sqlString = mysql.format(sql2, inserts);
-    console.log(`Executing MySQL query: ${sqlString}`);
-    return new Promise((resolve, reject) => {
-      connection.query(sqlString, function(err, results, fields3) {
-        if (err) {
-          reject(err);
-          console.log("There is an error. Disconnecting from database.");
-          connection.end();
-        } else {
-          console.log("Success...");
-          console.log(results);
-          console.log(fields3);
-          resolve(results);
-        }
+  return async (state) => {
+    const [resolvedTable, resolvedFields] = expandReferences(
+      state,
+      table,
+      fields2
+    );
+    const keys = Object.keys(resolvedFields);
+    const placeholders = keys.map(() => "?").join(", ");
+    const columns = keys.map(() => "??").join(", ");
+    const sqlString = mysql.format(
+      `INSERT INTO ?? (${columns}) VALUES (${placeholders})`,
+      [resolvedTable, ...keys]
+    );
+    try {
+      const [result, fields3] = await connection.execute(
+        sqlString,
+        Object.values(resolvedFields)
+      );
+      console.log("Success...");
+      return composeNextState(state, {
+        result,
+        fields: formatFields(fields3)
       });
-    }).then((data) => {
-      const nextState = { ...state, response: { body: data } };
-      return nextState;
-    });
+    } catch (err) {
+      console.log("Error inserting record.");
+      throw err;
+    }
   };
 }
 function upsert(table, fields2) {
-  return (state) => {
-    let { connection } = state;
-    const [valuesObj] = expandReferences(state, fields2);
-    const squelMysql = squel.useFlavour("mysql");
-    var insertParams = squelMysql.insert({
-      autoQuoteFieldNames: true
-    }).into(table).setFields(valuesObj).toParam();
-    var sql2 = insertParams.text;
-    var inserts = insertParams.values;
-    const insertString = mysql.format(sql2, inserts);
-    var updateParams = squelMysql.update({
-      autoQuoteFieldNames: true
-    }).table("").setFields(valuesObj).toParam();
-    var sql2 = updateParams.text;
-    var inserts = updateParams.values;
-    const updateString = mysql.format(sql2, inserts);
-    const upsertString = insertString + ` ON DUPLICATE KEY UPDATE ` + updateString.slice(10);
+  return async (state) => {
+    const [resolvedTable, resolvedFields] = expandReferences(
+      state,
+      table,
+      fields2
+    );
+    const insertQuery = knexInstance(resolvedTable).insert(resolvedFields);
+    const insertString = insertQuery.toString();
+    const updateParts = Object.keys(resolvedFields).map(
+      (key) => `${knexInstance.ref(key)} = VALUES(${knexInstance.ref(key)})`
+    );
+    const updateClause = updateParts.join(", ");
+    const upsertString = `${insertString} ON DUPLICATE KEY UPDATE ${updateClause}`;
     console.log("Executing MySQL query: " + upsertString);
-    return new Promise((resolve, reject) => {
-      connection.query(upsertString, function(err, results, fields3) {
-        if (err) {
-          reject(err);
-          console.log("That's an error. Disconnecting from database.");
-          connection.end();
-        } else {
-          console.log("Success...");
-          console.log(results);
-          console.log(fields3);
-          resolve(results);
-        }
-      });
-    }).then((data) => {
-      const nextState = { ...state, response: { body: data } };
-      return nextState;
-    });
+    try {
+      const [result, fields3] = await connection.execute(upsertString);
+      console.log("Success...");
+      return composeNextState(state, { result, fields: formatFields(fields3) });
+    } catch (err) {
+      console.log("That's an error.");
+      throw err;
+    }
   };
 }
 function upsertMany(table, data) {
-  return function(state) {
-    return new Promise(function(resolve, reject) {
-      const [rows] = expandReferences(state, data);
-      if (!rows || rows.length === 0) {
-        console.log("No records provided; skipping upsert.");
-        resolve(state);
-      }
-      const squelMysql = squel.useFlavour("mysql");
-      const columns = Object.keys(rows[0]);
-      let upsertSql = squelMysql.insert().into(table).setFieldsRows(rows);
-      columns.map((c) => {
-        upsertSql = upsertSql.onDupUpdate(`${c}=values(${c})`);
-      });
-      const upsertString = upsertSql.toString();
-      let { connection } = state;
-      connection.query(upsertString, function(err, results, fields2) {
-        if (err) {
-          reject(err);
-          console.log("That's an error. Disconnecting from database.");
-          connection.end();
-        } else {
-          console.log("Success...");
-          console.log(results);
-          console.log(fields2);
-          resolve(results);
-        }
-      });
-    }).then(function(data2) {
-      const nextState = { ...state, response: { body: data2 } };
-      return nextState;
-    });
+  return async (state) => {
+    const [resolvedTable, resolvedData] = expandReferences(state, table, data);
+    if (!resolvedData || resolvedData.length === 0) {
+      console.log("No records provided; skipping upsert.");
+      return state;
+    }
+    const columns = Object.keys(resolvedData[0]);
+    const insertQuery = knexInstance(resolvedTable).insert(resolvedData);
+    const insertString = insertQuery.toString();
+    const updateParts = columns.map(
+      (c) => `${knexInstance.ref(c)} = VALUES(${knexInstance.ref(c)})`
+    );
+    const updateClause = updateParts.join(", ");
+    const upsertString = `${insertString} ON DUPLICATE KEY UPDATE ${updateClause}`;
+    try {
+      const [result, fields2] = await connection.execute(upsertString);
+      console.log("Success...");
+      return composeNextState(state, { result, fields: formatFields(fields2) });
+    } catch (err) {
+      console.log("That's an error.");
+      throw err;
+    }
   };
 }
 
@@ -226,6 +244,7 @@ export {
   alterState,
   arrayToString,
   as,
+  assert,
   combine,
   cursor,
   dataPath,
@@ -241,6 +260,7 @@ export {
   insert,
   lastReferenceValue,
   merge,
+  setMockConnection,
   sourceValue,
   sql,
   upsert,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@openfn/language-mysql",
   "label": "MySQL",
-  "version": "3.0.6",
+  "version": "4.0.1",
   "description": "A MySQL Language Pack for OpenFn",
   "homepage": "https://docs.openfn.org",
   "main": "dist/index.cjs",
@@ -18,10 +18,8 @@
     "configuration-schema.json"
   ],
   "dependencies": {
-    "json-sql": "^0.3.10",
-    "mysql": "^2.13.0",
-    "squel": "^5.8.0",
-    "string-escape": "^0.3.0",
+    "knex": "^3.1.0",
+    "mysql2": "^3.15.3",
     "@openfn/language-common": "3.2.1"
   },
   "devDependencies": {
@@ -42,8 +40,9 @@
   "types": "types/index.d.ts",
   "scripts": {
     "build": "pnpm clean && build-adaptor mysql",
-    "test": "mocha --experimental-specifier-resolution=node --no-warnings",
-    "test:watch": "mocha -w --experimental-specifier-resolution=node --no-warnings",
+    "test": "mocha --experimental-specifier-resolution=node --no-warnings --exclude test/integration.js --recursive",
+    "test:watch": "mocha -w --experimental-specifier-resolution=node --no-warnings --exclude test/integration.js --recursive",
+    "test:integration": "mocha --experimental-specifier-resolution=node --no-warnings test/integration.js",
     "clean": "rimraf dist types docs",
     "pack": "pnpm pack --pack-destination ../../dist",
     "lint": "eslint src"

package/types/Adaptor.d.ts

@@ -1,67 +1,126 @@
+export function setMockConnection(mockConnection: any): void;
+/**
+ * State object
+ * @typedef {Object} MySQLState
+ * @property data - the query results object
+ * @property data.result - the query result rows
+ * @property data.fields - the query result fields
+ * @property queries - an array of queries executed. Queries are added if `options.writeSql` is true.
+ * @property references - an array of all previous data objects used in the Job
+ * @private
+ **/
+/**
+ * @typedef {Object} sqlOptions
+ * @property {array} [values] - An array of values for prepared statements.
+ * @property {boolean} [writeSql = false] - If true, logs the generated SQL statement. Defaults to false.
+ * @property {boolean} [execute = true] - If false, does not execute the SQL, just logs it and adds to state.queries. Defaults to true.
+ * */
+/**
+ * Execute a sequence of operations.
+ * Wraps `language-common/execute`, and prepends initial state for mysql.
+ * @private
+ * @param {Operations} operations - Operations to be performed.
+ * @returns {Operation}
+ */
+export function execute(...operations: Operations): Operation;
 /**
  * Execute a SQL statement. Take care when inserting values from state directly into a query,
  * as this can be a vector for injection attacks. See [OWASP SQL Injection Prevention Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/SQL_Injection_Prevention_Cheat_Sheet.html)
  * for guidelines
  * @example
  * sql(state => `select * from ${state.data.tableName};`, { writeSql: true })
+ * @example <caption>Prepared statements</caption>
+ * sql(state => `select * from ?? where id = ?;`, {
+ *   values: state => [state.data.tableName, state.data.id],
+ * });
  * @function
  * @public
- * @param {string|function} sqlQuery - The SQL query as a string or a function that returns a string using state.
- * @param {object} [options] - Optional options argument.
- * @param {boolean} [options.writeSql = false] - If true, logs the generated SQL statement. Defaults to false.
- * @param {boolean} [options.execute = true] - If false, does not execute the SQL, just logs it and adds to state.queries. Defaults to true.
+ * @param {string} sqlQuery - The sql query string.
+ * @param {sqlOptions} [options] -  The sql query options.
+ * @state {MySQLState}
  * @returns {Operation}
  */
-export function sql(sqlQuery: string | Function, options?: {
-    writeSql?: boolean;
-    execute?: boolean;
-}): Operation;
-/**
- * Execute a sequence of operations.
- * Wraps `language-common/execute`, and prepends initial state for mysql.
- * @private
- * @param {Operations} operations - Operations to be performed.
- * @returns {Operation}
- */
-export function execute(...operations: Operations): Operation;
+export function sql(sqlQuery: string, options?: sqlOptions): Operation;
 /**
  * Insert a record
- * @example <caption>Insert a record into the `users` table</caption>
- * insert("users", { name: (state) => state.data.name });
+ * @example <caption>Insert a record into a table</caption>
+ * insert("users", { name: "one", email: "one@openfn.org" });
  * @function
  * @public
  * @param {string} table - The target table
  * @param {object} fields - A fields object
+ * @state {MySQLState}
  * @returns {Operation}
  */
 export function insert(table: string, fields: object): Operation;
 /**
  * Insert or Update a record if matched
- * @example <caption>Upsert a record</caption>
- * upsert("table", { name: (state) => state.data.name });
+ * @example <caption>Upsert a record into a table</caption>
+ * upsert("users", { name: "Tuchi Dev" });
  * @function
  * @public
  * @param {string} table - The target table
  * @param {object} fields - A fields object
+ * @state {MySQLState}
  * @returns {Operation}
  */
 export function upsert(table: string, fields: object): Operation;
 /**
  * Insert or update multiple records using ON DUPLICATE KEY
  * @public
- * @example <caption>Upsert multiple records</caption>
+ * @example<caption>Upsert multiple records into a table</caption>
  * upsertMany(
- *   'users', // the DB table
+ *   "users", // the DB table
  *   [
- *     { name: 'one', email: 'one@openfn.org' },
- *     { name: 'two', email: 'two@openfn.org' },
+ *     { name: "one", email: "one@openfn.org" },
+ *     { name: "two", email: "two@openfn.org" },
  *   ]
- * )
+ * );
  * @function
  * @public
  * @param {string} table - The target table
- * @param {array} data - An array of objects or a function that returns an array
+ * @param {array} data - An array of objects fields
+ * @state {MySQLState}
  * @returns {Operation}
  */
 export function upsertMany(table: string, data: any[]): Operation;
-export { fn, fnIf, each, merge, field, fields, cursor, dateFns, combine, dataPath, dataValue, alterState, sourceValue, arrayToString, lastReferenceValue, as } from "@openfn/language-common";
+/**
+ * State object
+ */
+export type MySQLState = {
+    /**
+     * - the query results object
+     */
+    data: any;
+    /**
+     * - the query result rows
+     */
+    result: any;
+    /**
+     * - the query result fields
+     */
+    fields: any;
+    /**
+     * - an array of queries executed. Queries are added if `options.writeSql` is true.
+     */
+    queries: any;
+    /**
+     * - an array of all previous data objects used in the Job
+     */
+    references: any;
+};
+export type sqlOptions = {
+    /**
+     * - An array of values for prepared statements.
+     */
+    values?: any[];
+    /**
+     * - If true, logs the generated SQL statement. Defaults to false.
+     */
+    writeSql?: boolean;
+    /**
+     * - If false, does not execute the SQL, just logs it and adds to state.queries. Defaults to true.
+     */
+    execute?: boolean;
+};
+export { fn, fnIf, each, merge, field, fields, assert, cursor, dateFns, combine, dataPath, dataValue, alterState, sourceValue, arrayToString, lastReferenceValue, as } from "@openfn/language-common";