@openfn/language-maximo 0.3.0

package/dist/index.cjs

@@ -0,0 +1,308 @@
+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,
+  create: () => create,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  default: () => src_default,
+  each: () => import_language_common2.each,
+  execute: () => execute,
+  fetch: () => fetch,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  fn: () => import_language_common2.fn,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  sourceValue: () => import_language_common2.sourceValue,
+  update: () => update,
+  update75: () => update75
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  alterState: () => import_language_common2.alterState,
+  create: () => create,
+  dataPath: () => import_language_common2.dataPath,
+  dataValue: () => import_language_common2.dataValue,
+  each: () => import_language_common2.each,
+  execute: () => execute,
+  fetch: () => fetch,
+  field: () => import_language_common2.field,
+  fields: () => import_language_common2.fields,
+  fn: () => import_language_common2.fn,
+  lastReferenceValue: () => import_language_common2.lastReferenceValue,
+  merge: () => import_language_common2.merge,
+  sourceValue: () => import_language_common2.sourceValue,
+  update: () => update,
+  update75: () => update75
+});
+var import_language_common = require("@openfn/language-common");
+var import_request = __toESM(require("request"), 1);
+var import_url = require("url");
+var import_base_64 = __toESM(require("base-64"), 1);
+var import_utf8 = __toESM(require("utf8"), 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)(...operations)({ ...initialState, ...state });
+  };
+}
+function fetch(params) {
+  return (state) => {
+    function assembleError({ response, error }) {
+      if (response && [200, 201, 202].indexOf(response.statusCode) > -1)
+        return false;
+      if (error)
+        return error;
+      return new Error(`Server responded with ${response.statusCode}`);
+    }
+    const { endpoint, query, postUrl } = (0, import_language_common.expandReferences)(params)(state);
+    const { username, password, baseUrl } = state.configuration;
+    const authy = username + ":" + password;
+    const bytes = import_utf8.default.encode(authy);
+    const encoded = import_base_64.default.encode(bytes);
+    const url = (0, import_url.resolve)(baseUrl + "/", endpoint);
+    console.log("Fetching data from URL: " + url);
+    console.log("Applying query: " + JSON.stringify(query));
+    return new Promise((resolve, reject) => {
+      (0, import_request.default)(
+        {
+          url,
+          qs: query,
+          headers: {
+            maxauth: encoded
+          }
+        },
+        function(error, response, getResponseBody) {
+          error = assembleError({ error, response });
+          if (error) {
+            console.error("GET failed.");
+            console.log(response);
+            reject(error);
+          } else {
+            console.log("GET succeeded.");
+            console.log("Response body: " + getResponseBody);
+            import_request.default.post(
+              {
+                url: postUrl,
+                json: JSON.parse(getResponseBody)
+              },
+              function(error2, response2, postResponseBody) {
+                error2 = assembleError({ error: error2, response: response2 });
+                if (error2) {
+                  console.error("POST failed.");
+                  reject(error2);
+                } else {
+                  console.log("POST succeeded.");
+                  resolve(getResponseBody);
+                }
+              }
+            );
+          }
+        }
+      );
+    }).then((response) => {
+      console.log("Success:", response);
+      let result = typeof response === "object" ? response : JSON.parse(response);
+      return { ...state, references: [result, ...state.references] };
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function create(params) {
+  return (state) => {
+    function assembleError({ response, error }) {
+      if (response && [200, 201, 202].indexOf(response.statusCode) > -1)
+        return false;
+      if (error)
+        return error;
+      return new Error(`Server responded with ${response.statusCode}`);
+    }
+    const { endpoint, body } = (0, import_language_common.expandReferences)(params)(state);
+    const { username, password, baseUrl } = state.configuration;
+    const authy = username + ":" + password;
+    const bytes = import_utf8.default.encode(authy);
+    const encoded = import_base_64.default.encode(bytes);
+    const url = (0, import_url.resolve)(baseUrl + "/", endpoint);
+    console.log("Creating data at URL: " + url);
+    console.log("Post body:");
+    console.log(JSON.stringify(body, null, 4) + "\n");
+    return new Promise((resolve, reject) => {
+      import_request.default.post(
+        {
+          url,
+          json: body,
+          headers: {
+            maxauth: encoded
+          }
+        },
+        function(error, response, body2) {
+          error = assembleError({ error, response });
+          if (error) {
+            reject(error);
+            console.log(body2);
+          } else {
+            console.log(response);
+            console.log("Printing response body...\n");
+            console.log(JSON.stringify(body2, null, 4) + "\n");
+            console.log("POST succeeded.");
+            resolve(body2);
+          }
+        }
+      );
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function update(params) {
+  return (state) => {
+    function assembleError({ response, error }) {
+      if (response && [200, 201, 202].indexOf(response.statusCode) > -1)
+        return false;
+      if (error)
+        return error;
+      return new Error(`Server responded with ${response.statusCode}`);
+    }
+    const { endpoint, body } = (0, import_language_common.expandReferences)(params)(state);
+    const { username, password, baseUrl } = state.configuration;
+    const authy = username + ":" + password;
+    const bytes = import_utf8.default.encode(authy);
+    const encoded = import_base_64.default.encode(bytes);
+    const url = (0, import_url.resolve)(baseUrl + "/", endpoint);
+    console.log("Performing update at URL: " + url);
+    console.log("Update data:");
+    console.log(JSON.stringify(body, null, 4) + "\n");
+    return new Promise((resolve, reject) => {
+      import_request.default.post(
+        {
+          url,
+          json: body,
+          headers: {
+            maxauth: encoded,
+            "x-methodoverride": "PATCH",
+            patchtype: "MERGE"
+          }
+        },
+        function(error, response, body2) {
+          error = assembleError({ error, response });
+          if (error) {
+            reject(error);
+            console.log(body2);
+          } else {
+            console.log("Printing response body...\n");
+            console.log(JSON.stringify(body2, null, 4) + "\n");
+            console.log("Update succeeded.");
+            resolve(body2);
+          }
+        }
+      );
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function update75(params) {
+  return (state) => {
+    function assembleError({ response, error }) {
+      if (response && [200, 201, 202].indexOf(response.statusCode) > -1)
+        return false;
+      if (error)
+        return error;
+      return new Error(`Server responded with ${response.statusCode}`);
+    }
+    const { endpoint, body } = (0, import_language_common.expandReferences)(params)(state);
+    const { username, password, baseUrl } = state.configuration;
+    const authy = username + ":" + password;
+    const bytes = import_utf8.default.encode(authy);
+    const encoded = import_base_64.default.encode(bytes);
+    const url = (0, import_url.resolve)(baseUrl + "/", endpoint);
+    console.log("Performing update at URL: " + url);
+    console.log("Update data:");
+    console.log(JSON.stringify(body, null, 4) + "\n");
+    return new Promise((resolve, reject) => {
+      import_request.default.post(
+        {
+          url,
+          form: body,
+          headers: {
+            maxauth: encoded,
+            "x-methodoverride": "PATCH",
+            patchtype: "MERGE"
+          }
+        },
+        function(error, response, body2) {
+          error = assembleError({ error, response });
+          if (error) {
+            reject(error);
+            console.log(body2);
+          } else {
+            console.log("Printing update response body...\n");
+            console.log(JSON.stringify(body2, null, 4) + "\n");
+            console.log("Update succeeded.");
+            resolve(body2);
+          }
+        }
+      );
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  alterState,
+  create,
+  dataPath,
+  dataValue,
+  each,
+  execute,
+  fetch,
+  field,
+  fields,
+  fn,
+  lastReferenceValue,
+  merge,
+  sourceValue,
+  update,
+  update75
+});

package/dist/index.js

@@ -0,0 +1,282 @@
+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,
+  create: () => create,
+  dataPath: () => dataPath,
+  dataValue: () => dataValue,
+  each: () => each,
+  execute: () => execute,
+  fetch: () => fetch,
+  field: () => field,
+  fields: () => fields,
+  fn: () => fn,
+  lastReferenceValue: () => lastReferenceValue,
+  merge: () => merge,
+  sourceValue: () => sourceValue,
+  update: () => update,
+  update75: () => update75
+});
+import {
+  execute as commonExecute,
+  expandReferences
+} from "@openfn/language-common";
+import request from "request";
+import { resolve as resolveUrl } from "url";
+import base64 from "base-64";
+import utf8 from "utf8";
+import {
+  field,
+  fields,
+  sourceValue,
+  fn,
+  alterState,
+  each,
+  merge,
+  dataPath,
+  dataValue,
+  lastReferenceValue
+} from "@openfn/language-common";
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null
+  };
+  return (state) => {
+    return commonExecute(...operations)({ ...initialState, ...state });
+  };
+}
+function fetch(params) {
+  return (state) => {
+    function assembleError({ response, error }) {
+      if (response && [200, 201, 202].indexOf(response.statusCode) > -1)
+        return false;
+      if (error)
+        return error;
+      return new Error(`Server responded with ${response.statusCode}`);
+    }
+    const { endpoint, query, postUrl } = expandReferences(params)(state);
+    const { username, password, baseUrl } = state.configuration;
+    const authy = username + ":" + password;
+    const bytes = utf8.encode(authy);
+    const encoded = base64.encode(bytes);
+    const url = resolveUrl(baseUrl + "/", endpoint);
+    console.log("Fetching data from URL: " + url);
+    console.log("Applying query: " + JSON.stringify(query));
+    return new Promise((resolve, reject) => {
+      request(
+        {
+          url,
+          qs: query,
+          headers: {
+            maxauth: encoded
+          }
+        },
+        function(error, response, getResponseBody) {
+          error = assembleError({ error, response });
+          if (error) {
+            console.error("GET failed.");
+            console.log(response);
+            reject(error);
+          } else {
+            console.log("GET succeeded.");
+            console.log("Response body: " + getResponseBody);
+            request.post(
+              {
+                url: postUrl,
+                json: JSON.parse(getResponseBody)
+              },
+              function(error2, response2, postResponseBody) {
+                error2 = assembleError({ error: error2, response: response2 });
+                if (error2) {
+                  console.error("POST failed.");
+                  reject(error2);
+                } else {
+                  console.log("POST succeeded.");
+                  resolve(getResponseBody);
+                }
+              }
+            );
+          }
+        }
+      );
+    }).then((response) => {
+      console.log("Success:", response);
+      let result = typeof response === "object" ? response : JSON.parse(response);
+      return { ...state, references: [result, ...state.references] };
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function create(params) {
+  return (state) => {
+    function assembleError({ response, error }) {
+      if (response && [200, 201, 202].indexOf(response.statusCode) > -1)
+        return false;
+      if (error)
+        return error;
+      return new Error(`Server responded with ${response.statusCode}`);
+    }
+    const { endpoint, body } = expandReferences(params)(state);
+    const { username, password, baseUrl } = state.configuration;
+    const authy = username + ":" + password;
+    const bytes = utf8.encode(authy);
+    const encoded = base64.encode(bytes);
+    const url = resolveUrl(baseUrl + "/", endpoint);
+    console.log("Creating data at URL: " + url);
+    console.log("Post body:");
+    console.log(JSON.stringify(body, null, 4) + "\n");
+    return new Promise((resolve, reject) => {
+      request.post(
+        {
+          url,
+          json: body,
+          headers: {
+            maxauth: encoded
+          }
+        },
+        function(error, response, body2) {
+          error = assembleError({ error, response });
+          if (error) {
+            reject(error);
+            console.log(body2);
+          } else {
+            console.log(response);
+            console.log("Printing response body...\n");
+            console.log(JSON.stringify(body2, null, 4) + "\n");
+            console.log("POST succeeded.");
+            resolve(body2);
+          }
+        }
+      );
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function update(params) {
+  return (state) => {
+    function assembleError({ response, error }) {
+      if (response && [200, 201, 202].indexOf(response.statusCode) > -1)
+        return false;
+      if (error)
+        return error;
+      return new Error(`Server responded with ${response.statusCode}`);
+    }
+    const { endpoint, body } = expandReferences(params)(state);
+    const { username, password, baseUrl } = state.configuration;
+    const authy = username + ":" + password;
+    const bytes = utf8.encode(authy);
+    const encoded = base64.encode(bytes);
+    const url = resolveUrl(baseUrl + "/", endpoint);
+    console.log("Performing update at URL: " + url);
+    console.log("Update data:");
+    console.log(JSON.stringify(body, null, 4) + "\n");
+    return new Promise((resolve, reject) => {
+      request.post(
+        {
+          url,
+          json: body,
+          headers: {
+            maxauth: encoded,
+            "x-methodoverride": "PATCH",
+            patchtype: "MERGE"
+          }
+        },
+        function(error, response, body2) {
+          error = assembleError({ error, response });
+          if (error) {
+            reject(error);
+            console.log(body2);
+          } else {
+            console.log("Printing response body...\n");
+            console.log(JSON.stringify(body2, null, 4) + "\n");
+            console.log("Update succeeded.");
+            resolve(body2);
+          }
+        }
+      );
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+function update75(params) {
+  return (state) => {
+    function assembleError({ response, error }) {
+      if (response && [200, 201, 202].indexOf(response.statusCode) > -1)
+        return false;
+      if (error)
+        return error;
+      return new Error(`Server responded with ${response.statusCode}`);
+    }
+    const { endpoint, body } = expandReferences(params)(state);
+    const { username, password, baseUrl } = state.configuration;
+    const authy = username + ":" + password;
+    const bytes = utf8.encode(authy);
+    const encoded = base64.encode(bytes);
+    const url = resolveUrl(baseUrl + "/", endpoint);
+    console.log("Performing update at URL: " + url);
+    console.log("Update data:");
+    console.log(JSON.stringify(body, null, 4) + "\n");
+    return new Promise((resolve, reject) => {
+      request.post(
+        {
+          url,
+          form: body,
+          headers: {
+            maxauth: encoded,
+            "x-methodoverride": "PATCH",
+            patchtype: "MERGE"
+          }
+        },
+        function(error, response, body2) {
+          error = assembleError({ error, response });
+          if (error) {
+            reject(error);
+            console.log(body2);
+          } else {
+            console.log("Printing update response body...\n");
+            console.log(JSON.stringify(body2, null, 4) + "\n");
+            console.log("Update succeeded.");
+            resolve(body2);
+          }
+        }
+      );
+    }).then((data) => {
+      const nextState = { ...state, response: { body: data } };
+      return nextState;
+    });
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+export {
+  alterState,
+  create,
+  dataPath,
+  dataValue,
+  src_default as default,
+  each,
+  execute,
+  fetch,
+  field,
+  fields,
+  fn,
+  lastReferenceValue,
+  merge,
+  sourceValue,
+  update,
+  update75
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@openfn/language-maximo",
+  "version": "0.3.0",
+  "description": "An IBM Maximo EAM Language Pack for OpenFn",
+  "main": "dist/index.cjs",
+  "author": "Open Function Group",
+  "license": "LGPLv3",
+  "files": [
+    "dist/",
+    "types/",
+    "ast.json",
+    "configuration-schema.json"
+  ],
+  "dependencies": {
+    "@openfn/language-common": "^1.7.5",
+    "base-64": "^0.1.0",
+    "request": "^2.88.2",
+    "utf8": "^2.1.2"
+  },
+  "devDependencies": {
+    "@openfn/buildtools": "^1.0.2",
+    "@openfn/simple-ast": "0.4.1",
+    "assertion-error": "^2.0.0",
+    "babel-cli": "^6.26.0",
+    "babel-core": "^6.26.3",
+    "babel-preset-es2015": "^6.24.1",
+    "babel-preset-stage-0": "^6.24.1",
+    "chai": "^4.3.7",
+    "deep-eql": "^4.1.2",
+    "esno": "^0.16.3",
+    "mocha": "^10.1.0",
+    "nock": "^13.2.9",
+    "rimraf": "^3.0.2"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openfn/adaptors.git"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "types/index.d.ts",
+  "scripts": {
+    "build": "pnpm clean && build-adaptor maximo",
+    "test": "mocha --experimental-specifier-resolution=node --no-warnings",
+    "test:watch": "mocha -w --experimental-specifier-resolution=node --no-warnings",
+    "clean": "rimraf dist types docs",
+    "pack": "pnpm pack --pack-destination ../../dist"
+  }
+}

package/types/Adaptor.d.ts

@@ -0,0 +1,54 @@
+/** @module Adaptor */
+/**
+ * Execute a sequence of operations.
+ * Wraps `@openfn/language-common/execute`, and prepends initial state for http.
+ * @example
+ * execute(
+ *   create('foo'),
+ *   delete('bar')
+ * )(state)
+ * @function
+ * @param {Operations} operations - Operations to be performed.
+ * @returns {Operation}
+ */
+export function execute(...operations: Operations): Operation;
+/**
+ * Make a GET request and POST it somewhere else
+ * @example
+ * fetch({
+ *  endpoint: 'maxrest/rest/os/mxinventory',
+ *  query: {
+ *    ITEMNUM: '01226',
+ *    _format: 'json',
+ *  },
+ *  postUrl: 'https://www.openfn.org/inbox/not-real',
+ * });
+ * @function
+ * @param {object} params - data to make the fetch
+ * @returns {Operation}
+ */
+export function fetch(params: object): Operation;
+export function create(params: any): (state: any) => Promise<any>;
+/**
+ * Make an update in Maximo 7.6 and beyond
+ * @example
+ * execute(
+ *   update(params)
+ * )(state)
+ * @function
+ * @param {object} params - data to make the update
+ * @returns {Operation}
+ */
+export function update(params: object): Operation;
+/**
+ * Make an upadte in Maximo 7.5
+ * @example
+ * execute(
+ *   update75(params)
+ * )(state)
+ * @function
+ * @param {object} params - data to make the update
+ * @returns {Operation}
+ */
+export function update75(params: object): Operation;
+export { field, fields, sourceValue, fn, alterState, each, merge, dataPath, dataValue, lastReferenceValue } from "@openfn/language-common";

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export default Adaptor;
+export * from "./Adaptor";
+import * as Adaptor from "./Adaptor";