@openfn/language-satusehat 1.0.0

package/dist/index.cjs

@@ -0,0 +1,271 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.js
+var src_exports = {};
+__export(src_exports, {
+  alterState: () => import_language_common3.alterState,
+  arrayToString: () => import_language_common3.arrayToString,
+  combine: () => import_language_common3.combine,
+  dataPath: () => import_language_common3.dataPath,
+  dataValue: () => import_language_common3.dataValue,
+  default: () => src_default,
+  each: () => import_language_common3.each,
+  execute: () => execute,
+  field: () => import_language_common3.field,
+  fields: () => import_language_common3.fields,
+  fn: () => import_language_common3.fn,
+  get: () => get,
+  http: () => import_language_common3.http,
+  lastReferenceValue: () => import_language_common3.lastReferenceValue,
+  merge: () => import_language_common3.merge,
+  patch: () => patch,
+  post: () => post,
+  put: () => put,
+  sourceValue: () => import_language_common3.sourceValue
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  alterState: () => import_language_common3.alterState,
+  arrayToString: () => import_language_common3.arrayToString,
+  combine: () => import_language_common3.combine,
+  dataPath: () => import_language_common3.dataPath,
+  dataValue: () => import_language_common3.dataValue,
+  each: () => import_language_common3.each,
+  execute: () => execute,
+  field: () => import_language_common3.field,
+  fields: () => import_language_common3.fields,
+  fn: () => import_language_common3.fn,
+  get: () => get,
+  http: () => import_language_common3.http,
+  lastReferenceValue: () => import_language_common3.lastReferenceValue,
+  merge: () => import_language_common3.merge,
+  patch: () => patch,
+  post: () => post,
+  put: () => put,
+  sourceValue: () => import_language_common3.sourceValue
+});
+var import_language_common2 = require("@openfn/language-common");
+var import_util2 = require("@openfn/language-common/util");
+
+// src/Utils.js
+var import_language_common = require("@openfn/language-common");
+var import_util = require("@openfn/language-common/util");
+var generateUserAgent = () => {
+  return `nodejs/${process.version} @openfn/language-satusehat`;
+};
+var authorize = (state) => {
+  const auth = state.configuration;
+  if (auth.access_token) {
+    return state;
+  }
+  const clientId = auth.clientId;
+  const clientSecret = auth.clientSecret;
+  const headers = {};
+  if (clientId && clientSecret) {
+    Object.assign(headers, {
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": generateUserAgent()
+    });
+    const body = new URLSearchParams();
+    body.append("client_id", clientId);
+    body.append("client_secret", clientSecret);
+    const options = {
+      body: body.toString(),
+      headers,
+      method: "POST",
+      parseAs: "json",
+      baseUrl: auth.baseUrl,
+      query: {
+        grant_type: "client_credentials"
+      },
+      maxRedirections: 1
+    };
+    return (0, import_util.request)("POST", "/oauth2/v1/accesstoken", options).then(
+      (response) => {
+        return {
+          ...state,
+          configuration: {
+            ...state.configuration,
+            access_token: response.body.access_token
+          }
+        };
+      }
+    );
+  } else {
+    throw new Error(
+      "Invalid authorization credentials. Include clientId and clientSecret in state.configuration"
+    );
+  }
+};
+var prepareNextState = (state, response, callback = (s) => s) => {
+  const { body, ...responseWithoutBody } = response;
+  const nextState = {
+    ...(0, import_language_common.composeNextState)(state, response.body),
+    response: responseWithoutBody
+  };
+  return callback(nextState);
+};
+async function request(configuration, path, opts) {
+  const { baseUrl, access_token } = configuration;
+  const {
+    method,
+    data,
+    params = {},
+    parseAs = "json",
+    contentType = "application/json"
+  } = opts;
+  const headers = {
+    Authorization: `Bearer ${access_token}`,
+    "User-Agent": generateUserAgent(),
+    "content-type": contentType
+  };
+  const options = {
+    body: data,
+    headers,
+    query: params,
+    parseAs,
+    maxRedirections: 1,
+    baseUrl: `${baseUrl}/fhir-r4/v1/`
+  };
+  return (0, import_util.request)(method, path, options).then(import_util.logResponse);
+}
+
+// src/Adaptor.js
+var import_language_common3 = require("@openfn/language-common");
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null
+  };
+  return (state) => {
+    return (0, import_language_common2.execute)(
+      authorize,
+      ...operations
+    )({
+      ...initialState,
+      ...state
+    });
+  };
+}
+function get(path, params = {}, callback = (s) => s) {
+  return async (state) => {
+    const [resolvedPath, resolvedParams] = (0, import_util2.expandReferences)(
+      state,
+      path,
+      params
+    );
+    try {
+      const response = await request(state.configuration, `/${resolvedPath}`, {
+        method: "GET",
+        params: resolvedParams
+      });
+      return prepareNextState(state, response, callback);
+    } catch (e) {
+      throw e.body ?? e;
+    }
+  };
+}
+function post(path, data, params = {}, callback = (s) => s) {
+  return async (state) => {
+    const [resolvedPath, resolvedData, resolvedParams] = (0, import_util2.expandReferences)(
+      state,
+      path,
+      data,
+      params
+    );
+    try {
+      const response = await request(state.configuration, `/${resolvedPath}`, {
+        method: "POST",
+        data: resolvedData,
+        params: resolvedParams
+      });
+      return prepareNextState(state, response, callback);
+    } catch (e) {
+      throw e.body.error ?? e;
+    }
+  };
+}
+function put(path, data, params = {}, callback = (s) => s) {
+  return async (state) => {
+    const [resolvedPath, resolvedData, resolvedParams] = (0, import_util2.expandReferences)(
+      state,
+      path,
+      data,
+      params
+    );
+    try {
+      const response = await request(state.configuration, `/${resolvedPath}`, {
+        method: "PUT",
+        data: resolvedData,
+        params: resolvedParams
+      });
+      return prepareNextState(state, response, callback);
+    } catch (e) {
+      throw e.body.error ?? e;
+    }
+  };
+}
+function patch(path, data, params = {}, callback = (s) => s) {
+  return async (state) => {
+    const [resolvedPath, resolvedData, resolvedParams] = (0, import_util2.expandReferences)(
+      state,
+      path,
+      data,
+      params
+    );
+    try {
+      const response = await request(state.configuration, `/${resolvedPath}`, {
+        method: "PATCH",
+        data: JSON.stringify(resolvedData),
+        params: resolvedParams,
+        contentType: "application/json-patch+json"
+      });
+      return prepareNextState(state, response, callback);
+    } catch (e) {
+      throw e.body ?? e;
+    }
+  };
+}
+
+// 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,
+  get,
+  http,
+  lastReferenceValue,
+  merge,
+  patch,
+  post,
+  put,
+  sourceValue
+});

package/dist/index.js

@@ -0,0 +1,251 @@
+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,
+  get: () => get,
+  http: () => http,
+  lastReferenceValue: () => lastReferenceValue,
+  merge: () => merge,
+  patch: () => patch,
+  post: () => post,
+  put: () => put,
+  sourceValue: () => sourceValue
+});
+import { execute as commonExecute } from "@openfn/language-common";
+import { expandReferences } from "@openfn/language-common/util";
+
+// src/Utils.js
+import { composeNextState } from "@openfn/language-common";
+import {
+  request as commonRequest,
+  logResponse
+} from "@openfn/language-common/util";
+var generateUserAgent = () => {
+  return `nodejs/${process.version} @openfn/language-satusehat`;
+};
+var authorize = (state) => {
+  const auth = state.configuration;
+  if (auth.access_token) {
+    return state;
+  }
+  const clientId = auth.clientId;
+  const clientSecret = auth.clientSecret;
+  const headers = {};
+  if (clientId && clientSecret) {
+    Object.assign(headers, {
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": generateUserAgent()
+    });
+    const body = new URLSearchParams();
+    body.append("client_id", clientId);
+    body.append("client_secret", clientSecret);
+    const options = {
+      body: body.toString(),
+      headers,
+      method: "POST",
+      parseAs: "json",
+      baseUrl: auth.baseUrl,
+      query: {
+        grant_type: "client_credentials"
+      },
+      maxRedirections: 1
+    };
+    return commonRequest("POST", "/oauth2/v1/accesstoken", options).then(
+      (response) => {
+        return {
+          ...state,
+          configuration: {
+            ...state.configuration,
+            access_token: response.body.access_token
+          }
+        };
+      }
+    );
+  } else {
+    throw new Error(
+      "Invalid authorization credentials. Include clientId and clientSecret in state.configuration"
+    );
+  }
+};
+var prepareNextState = (state, response, callback = (s) => s) => {
+  const { body, ...responseWithoutBody } = response;
+  const nextState = {
+    ...composeNextState(state, response.body),
+    response: responseWithoutBody
+  };
+  return callback(nextState);
+};
+async function request(configuration, path, opts) {
+  const { baseUrl, access_token } = configuration;
+  const {
+    method,
+    data,
+    params = {},
+    parseAs = "json",
+    contentType = "application/json"
+  } = opts;
+  const headers = {
+    Authorization: `Bearer ${access_token}`,
+    "User-Agent": generateUserAgent(),
+    "content-type": contentType
+  };
+  const options = {
+    body: data,
+    headers,
+    query: params,
+    parseAs,
+    maxRedirections: 1,
+    baseUrl: `${baseUrl}/fhir-r4/v1/`
+  };
+  return commonRequest(method, path, options).then(logResponse);
+}
+
+// src/Adaptor.js
+import {
+  fn,
+  alterState,
+  arrayToString,
+  combine,
+  dataPath,
+  dataValue,
+  each,
+  field,
+  fields,
+  http,
+  lastReferenceValue,
+  merge,
+  sourceValue
+} from "@openfn/language-common";
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null
+  };
+  return (state) => {
+    return commonExecute(
+      authorize,
+      ...operations
+    )({
+      ...initialState,
+      ...state
+    });
+  };
+}
+function get(path, params = {}, callback = (s) => s) {
+  return async (state) => {
+    const [resolvedPath, resolvedParams] = expandReferences(
+      state,
+      path,
+      params
+    );
+    try {
+      const response = await request(state.configuration, `/${resolvedPath}`, {
+        method: "GET",
+        params: resolvedParams
+      });
+      return prepareNextState(state, response, callback);
+    } catch (e) {
+      throw e.body ?? e;
+    }
+  };
+}
+function post(path, data, params = {}, callback = (s) => s) {
+  return async (state) => {
+    const [resolvedPath, resolvedData, resolvedParams] = expandReferences(
+      state,
+      path,
+      data,
+      params
+    );
+    try {
+      const response = await request(state.configuration, `/${resolvedPath}`, {
+        method: "POST",
+        data: resolvedData,
+        params: resolvedParams
+      });
+      return prepareNextState(state, response, callback);
+    } catch (e) {
+      throw e.body.error ?? e;
+    }
+  };
+}
+function put(path, data, params = {}, callback = (s) => s) {
+  return async (state) => {
+    const [resolvedPath, resolvedData, resolvedParams] = expandReferences(
+      state,
+      path,
+      data,
+      params
+    );
+    try {
+      const response = await request(state.configuration, `/${resolvedPath}`, {
+        method: "PUT",
+        data: resolvedData,
+        params: resolvedParams
+      });
+      return prepareNextState(state, response, callback);
+    } catch (e) {
+      throw e.body.error ?? e;
+    }
+  };
+}
+function patch(path, data, params = {}, callback = (s) => s) {
+  return async (state) => {
+    const [resolvedPath, resolvedData, resolvedParams] = expandReferences(
+      state,
+      path,
+      data,
+      params
+    );
+    try {
+      const response = await request(state.configuration, `/${resolvedPath}`, {
+        method: "PATCH",
+        data: JSON.stringify(resolvedData),
+        params: resolvedParams,
+        contentType: "application/json-patch+json"
+      });
+      return prepareNextState(state, response, callback);
+    } catch (e) {
+      throw e.body ?? e;
+    }
+  };
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+export {
+  alterState,
+  arrayToString,
+  combine,
+  dataPath,
+  dataValue,
+  src_default as default,
+  each,
+  execute,
+  field,
+  fields,
+  fn,
+  get,
+  http,
+  lastReferenceValue,
+  merge,
+  patch,
+  post,
+  put,
+  sourceValue
+};

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@openfn/language-satusehat",
+  "version": "1.0.0",
+  "description": "OpenFn satusehat adaptor",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "author": "Open Function Group",
+  "license": "LGPLv3",
+  "files": [
+    "dist/",
+    "types/",
+    "ast.json",
+    "configuration-schema.json"
+  ],
+  "dependencies": {
+    "@openfn/language-common": "1.13.4"
+  },
+  "devDependencies": {
+    "assertion-error": "2.0.0",
+    "chai": "4.3.6",
+    "deep-eql": "4.1.1",
+    "esno": "^0.16.3",
+    "mocha": "9.2.2",
+    "rimraf": "3.0.2",
+    "undici": "^5.22.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openfn/adaptors.git"
+  },
+  "types": "types/index.d.ts",
+  "main": "dist/index.cjs",
+  "scripts": {
+    "build": "pnpm clean && build-adaptor satusehat",
+    "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",
+    "lint": "eslint src"
+  }
+}

package/types/Adaptor.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Execute a sequence of operations.
+ * Wraps `language-common/execute` to make working with this API easier.
+ * @example
+ * execute(
+ *   create('foo'),
+ *   delete('bar')
+ * )(state)
+ * @private
+ * @param {Operations} operations - Operations to be performed.
+ * @returns {Operation}
+ */
+export function execute(...operations: Operations): Operation;
+/**
+ * Make a get request to any satusehat endpoint
+ * @public
+ * @example
+ * get("Organization", {"name": "somename"})
+ * @function
+ * @param {string} path - Path to resource
+ * @param {object} params - Optional request params such as name.
+ * @param {function} callback - An optional callback to handle the response
+ * @returns {Operation}
+ */
+export function get(path: string, params?: object, callback?: Function): Operation;
+/**
+ * Make a post request to satusehat
+ * @example
+ * post(
+ *   "Organization",
+ *  { "resourceType": "Organization", "active": true,
+ *  }
+ * );
+ * @function
+ * @param {string} path - Path to resource
+ * @param {object} data - Object or JSON which defines data that will be used to create a given instance of resource
+ * @param {Object} params - Optional request params.
+ * @param {function} [callback] - Optional callback to handle the response
+ * @returns {Operation}
+ */
+export function post(path: string, data: object, params?: any, callback?: Function): Operation;
+/**
+ * Make a put request to satusehat
+ * @example
+ * put(
+ *   "Organization/123",
+ *  { "resourceType": "Organization", "active": false,
+ *  }
+ * );
+ * @function
+ * @param {string} path - Path to resource and exact item to be updated
+ * @param {object} data - Object or JSON which defines data that will be used to update a given instance of resource
+ * @param {Object} params - Optional request params.
+ * @param {function} [callback] - Optional callback to handle the response
+ * @returns {Operation}
+ */
+export function put(path: string, data: object, params?: any, callback?: Function): Operation;
+/**
+ * Make a patch request to satusehat
+ * @example
+ * patch(
+ *   "Organization/123",
+ *    [{
+ * "op": "replace", // Operation - `replace` is the only one used to change a specific property or element
+ *  "path": "/language", // Path - The name of property/element of resource to be replaced
+ *  "value": "id" // Value- The value to be replaced
+ *}]
+ *
+ * );
+ * @function
+ * @param {string} path - Path to resource and exact item to be partially updated
+ * @param {Array} data - An array of objects which defines data that will be used to partially update a given instance of resource
+ * @param {Object} params - Optional request params.
+ * @param {function} [callback] - Optional callback to handle the response
+ * @returns {Operation}
+ */
+export function patch(path: string, data: any[], params?: any, callback?: Function): Operation;
+export { fn, alterState, arrayToString, combine, dataPath, dataValue, each, field, fields, http, lastReferenceValue, merge, sourceValue } from "@openfn/language-common";

package/types/Utils.d.ts

@@ -0,0 +1,3 @@
+export function request(configuration: any, path: any, opts: any): Promise<any>;
+export function authorize(state: any): any;
+export function prepareNextState(state: any, response: any, callback?: (s: any) => any): any;

package/types/index.d.ts

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