@openfn/language-mysql 1.2.0 → 1.3.1

package/README.md

@@ -1,4 +1,4 @@
-# Language MySQL [![Build Status](https://travis-ci.org/OpenFn/language-mysql.svg?branch=master)](https://travis-ci.org/OpenFn/language-mysql)
+# Language MySQL
 
 Language Pack for building expressions and operations to run MySQL queries.
 
@@ -21,6 +21,7 @@ for the full list of available helper functions including `upsert(...)`.**
 ```
 
 ## Execute a query
+
 Execute an sql query with the node mysql package.
 
 ```js
@@ -34,7 +35,9 @@ query({
 ```
 
 ## Execute a sql query
-This function takes either a `string` or a `function` that takes states and returns a string.
+
+This function takes either a `string` or a `function` that takes states and
+returns a string.
 
 ```js
 sqlString(state => {
@@ -77,13 +80,38 @@ upsert(
 );
 ```
 
+## Upsert many records
+
+This function allows the upsert of a set of records inside a table all at once.
+
+```js
+upsertMany(
+  'users', // the DB table
+  [
+    { name: 'one', email: 'one@openfn.org' },
+    { name: 'two', email: 'two@openfn.org' },
+  ]
+);
+```
+
+or
+
+```js
+upsertMany('users', state =>
+  state.data.users.map(user => {
+    name: user['name'],
+    email: user['email']
+  })
+);
+```
+
 ## Development
 
-Clone the repo, run `npm install`.
+Clone the [adaptors monorepo](https://github.com/OpenFn/adaptors). Follow the
+`Getting Started` guide inside to get set up.
 
-Run tests using `npm run test` or `npm run test:watch`
+Run tests using `pnpm run test` or `pnpm run test:watch`
 
-Build the project using `make`.
+Build the project using `pnpm build`.
 
-To build the docs for this repo, run
-`./node_modules/.bin/jsdoc --readme ./README.md ./lib -d docs`.
+To just build the docs run `pnpm build docs`

package/ast.json

@@ -19,9 +19,8 @@
             "description": "upsertMany(\n  'users', // the DB table\n  [\n    { name: 'one', email: 'one@openfn.org' },\n    { name: 'two', email: 'two@openfn.org' },\n  ]\n)"
           },
           {
-            "title": "constructor",
+            "title": "function",
             "description": null,
-            "type": null,
             "name": null
           },
           {

package/configuration-schema.json

@@ -0,0 +1,44 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "properties": {
+      "host": {
+        "title": "Host URL",
+        "type": "string",
+        "description": "The database instance host URL",
+        "format": "uri",
+        "minLength": 1
+      },
+      "port": {
+        "title": "Port",
+        "type": "integer",
+        "default": 3306,
+        "description": "Database instance port",
+        "minLength": 1
+      },
+      "database": {
+        "title": "Database",
+        "type": "string",
+        "description": "The database name",
+        "minLength": 1
+      },
+      "user": {
+        "title": "Username",
+        "type": "string",
+        "description": "The username to log in the database",
+        "minLength": 1
+      },
+      "password": {
+        "title": "Password",
+        "type": "string",
+        "description": "The password to log in the database",
+        "writeOnly": true,
+        "minLength": 1
+      }
+    },
+    "type": "object",
+    "additionalProperties": true,
+    "required": [
+      "host",
+      "database"
+    ]
+  }

package/dist/index.cjs

@@ -0,0 +1,270 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var src_exports = {};
+__export(src_exports, {
+  alterState: () => import_language_common2.alterState,
+  arrayToString: () => import_language_common2.arrayToString,
+  combine: () => import_language_common2.combine,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  default: () => src_default,
+  each: () => import_language_common2.each,
+  execute: () => execute,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  fn: () => import_language_common2.fn,
+  http: () => import_language_common2.http,
+  insert: () => insert,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  query: () => query,
+  sourceValue: () => import_language_common2.sourceValue,
+  sqlString: () => sqlString,
+  upsert: () => upsert,
+  upsertMany: () => upsertMany
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  alterState: () => import_language_common2.alterState,
+  arrayToString: () => import_language_common2.arrayToString,
+  combine: () => import_language_common2.combine,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  each: () => import_language_common2.each,
+  execute: () => execute,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  fn: () => import_language_common2.fn,
+  http: () => import_language_common2.http,
+  insert: () => insert,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  query: () => query,
+  sourceValue: () => import_language_common2.sourceValue,
+  sqlString: () => sqlString,
+  upsert: () => upsert,
+  upsertMany: () => upsertMany
+});
+var import_language_common = require("@openfn/language-common");
+var import_mysql = __toESM(require("mysql"), 1);
+var import_squel = __toESM(require("squel"), 1);
+var import_language_common2 = require("@openfn/language-common");
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null
+  };
+  return (state) => {
+    return (0, import_language_common.execute)(
+      connect,
+      ...operations,
+      disconnect,
+      cleanupState
+    )({ ...initialState, ...state });
+  };
+}
+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_language_common.expandReferences)(fields2)(state);
+    const squelMysql = import_squel.default.useFlavour("mysql");
+    var sqlParams = squelMysql.insert({
+      autoQuoteFieldNames: true
+    }).into(table).setFields(valuesObj).toParam();
+    var sql = sqlParams.text;
+    var inserts = sqlParams.values;
+    sqlString = import_mysql.default.format(sql, 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);
+        }
+      });
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function upsert(table, fields2) {
+  return (state) => {
+    let { connection } = state;
+    const valuesObj = (0, import_language_common.expandReferences)(fields2)(state);
+    const squelMysql = import_squel.default.useFlavour("mysql");
+    var insertParams = squelMysql.insert({
+      autoQuoteFieldNames: true
+    }).into(table).setFields(valuesObj).toParam();
+    var sql = insertParams.text;
+    var inserts = insertParams.values;
+    const insertString = import_mysql.default.format(sql, inserts);
+    var updateParams = squelMysql.update({
+      autoQuoteFieldNames: true
+    }).table("").setFields(valuesObj).toParam();
+    var sql = updateParams.text;
+    var inserts = updateParams.values;
+    const updateString = import_mysql.default.format(sql, inserts);
+    const upsertString = insertString + ` ON DUPLICATE KEY UPDATE ` + updateString.slice(10);
+    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;
+    });
+  };
+}
+function upsertMany(table, data) {
+  return function(state) {
+    return new Promise(function(resolve, reject) {
+      const rows = (0, import_language_common.expandReferences)(data)(state);
+      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;
+    });
+  };
+}
+function query(options) {
+  return (state) => {
+    let { connection } = state;
+    const opts = (0, import_language_common.expandReferences)(options)(state);
+    console.log(
+      "Executing MySQL statement with options: " + JSON.stringify(opts, 2, null)
+    );
+    return new Promise((resolve, reject) => {
+      connection.query(opts, function(err, results, fields2) {
+        if (err) {
+          reject(err);
+          console.log("That's an error. Disconnecting from database.");
+          connection.end();
+        } else {
+          console.log("Success...");
+          resolve(JSON.parse(JSON.stringify(results)));
+        }
+      });
+    }).then((data) => {
+      console.log(data);
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function sqlString(queryString) {
+  return (state) => {
+    return query({ sql: queryString })(state);
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alterState,
+  arrayToString,
+  combine,
+  dataPath,
+  dataValue,
+  each,
+  execute,
+  field,
+  fields,
+  fn,
+  http,
+  insert,
+  lastReferenceValue,
+  merge,
+  query,
+  sourceValue,
+  sqlString,
+  upsert,
+  upsertMany
+});

package/dist/index.js

@@ -0,0 +1,243 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  alterState: () => alterState,
+  arrayToString: () => arrayToString,
+  combine: () => combine,
+  dataPath: () => dataPath,
+  dataValue: () => dataValue,
+  each: () => each,
+  execute: () => execute,
+  field: () => field,
+  fields: () => fields,
+  fn: () => fn,
+  http: () => http,
+  insert: () => insert,
+  lastReferenceValue: () => lastReferenceValue,
+  merge: () => merge,
+  query: () => query,
+  sourceValue: () => sourceValue,
+  sqlString: () => sqlString,
+  upsert: () => upsert,
+  upsertMany: () => upsertMany
+});
+import {
+  execute as commonExecute,
+  expandReferences
+} from "@openfn/language-common";
+import mysql from "mysql";
+import squel from "squel";
+import {
+  field,
+  fields,
+  sourceValue,
+  alterState,
+  fn,
+  arrayToString,
+  each,
+  combine,
+  merge,
+  dataPath,
+  dataValue,
+  lastReferenceValue,
+  http
+} from "@openfn/language-common";
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null
+  };
+  return (state) => {
+    return commonExecute(
+      connect,
+      ...operations,
+      disconnect,
+      cleanupState
+    )({ ...initialState, ...state });
+  };
+}
+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(fields2)(state);
+    const squelMysql = squel.useFlavour("mysql");
+    var sqlParams = squelMysql.insert({
+      autoQuoteFieldNames: true
+    }).into(table).setFields(valuesObj).toParam();
+    var sql = sqlParams.text;
+    var inserts = sqlParams.values;
+    sqlString = mysql.format(sql, 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);
+        }
+      });
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function upsert(table, fields2) {
+  return (state) => {
+    let { connection } = state;
+    const valuesObj = expandReferences(fields2)(state);
+    const squelMysql = squel.useFlavour("mysql");
+    var insertParams = squelMysql.insert({
+      autoQuoteFieldNames: true
+    }).into(table).setFields(valuesObj).toParam();
+    var sql = insertParams.text;
+    var inserts = insertParams.values;
+    const insertString = mysql.format(sql, inserts);
+    var updateParams = squelMysql.update({
+      autoQuoteFieldNames: true
+    }).table("").setFields(valuesObj).toParam();
+    var sql = updateParams.text;
+    var inserts = updateParams.values;
+    const updateString = mysql.format(sql, inserts);
+    const upsertString = insertString + ` ON DUPLICATE KEY UPDATE ` + updateString.slice(10);
+    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;
+    });
+  };
+}
+function upsertMany(table, data) {
+  return function(state) {
+    return new Promise(function(resolve, reject) {
+      const rows = expandReferences(data)(state);
+      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;
+    });
+  };
+}
+function query(options) {
+  return (state) => {
+    let { connection } = state;
+    const opts = expandReferences(options)(state);
+    console.log(
+      "Executing MySQL statement with options: " + JSON.stringify(opts, 2, null)
+    );
+    return new Promise((resolve, reject) => {
+      connection.query(opts, function(err, results, fields2) {
+        if (err) {
+          reject(err);
+          console.log("That's an error. Disconnecting from database.");
+          connection.end();
+        } else {
+          console.log("Success...");
+          resolve(JSON.parse(JSON.stringify(results)));
+        }
+      });
+    }).then((data) => {
+      console.log(data);
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function sqlString(queryString) {
+  return (state) => {
+    return query({ sql: queryString })(state);
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+export {
+  alterState,
+  arrayToString,
+  combine,
+  dataPath,
+  dataValue,
+  src_default as default,
+  each,
+  execute,
+  field,
+  fields,
+  fn,
+  http,
+  insert,
+  lastReferenceValue,
+  merge,
+  query,
+  sourceValue,
+  sqlString,
+  upsert,
+  upsertMany
+};