@openfn/language-wigal-sms 0.1.0

package/dist/index.cjs

@@ -0,0 +1,232 @@
+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, {
+  cursor: () => import_language_common3.cursor,
+  dataPath: () => import_language_common3.dataPath,
+  dataValue: () => import_language_common3.dataValue,
+  dateFns: () => import_language_common3.dateFns,
+  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,
+  fnIf: () => import_language_common3.fnIf,
+  lastReferenceValue: () => import_language_common3.lastReferenceValue,
+  merge: () => import_language_common3.merge,
+  sendSms: () => sendSms,
+  sourceValue: () => import_language_common3.sourceValue
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/Adaptor.js
+var Adaptor_exports = {};
+__export(Adaptor_exports, {
+  cursor: () => import_language_common3.cursor,
+  dataPath: () => import_language_common3.dataPath,
+  dataValue: () => import_language_common3.dataValue,
+  dateFns: () => import_language_common3.dateFns,
+  each: () => import_language_common3.each,
+  execute: () => execute,
+  field: () => import_language_common3.field,
+  fields: () => import_language_common3.fields,
+  fn: () => import_language_common3.fn,
+  fnIf: () => import_language_common3.fnIf,
+  lastReferenceValue: () => import_language_common3.lastReferenceValue,
+  merge: () => import_language_common3.merge,
+  sendSms: () => sendSms,
+  sourceValue: () => import_language_common3.sourceValue
+});
+var import_language_common2 = require("@openfn/language-common");
+
+// src/util.js
+var import_undici = __toESM(require("undici"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_util = require("@openfn/language-common/util");
+var import_language_common = require("@openfn/language-common");
+var client;
+var getClient = (baseUrl) => {
+  if (baseUrl) {
+    const url = new URL(baseUrl);
+    client = new import_undici.default.Client(url.origin);
+  }
+  return client;
+};
+var setMockClient = (mockClient) => {
+  client = mockClient;
+};
+var prepareNextState = async (state, response) => {
+  const { body, ...responseWithoutBody } = response;
+  const result = await body.json();
+  if (!state.references) {
+    state.references = [];
+  }
+  const nextState = {
+    ...(0, import_language_common.composeNextState)(state, result),
+    response: responseWithoutBody
+  };
+  return nextState;
+};
+var request = (path, options) => {
+  return async (state) => {
+    const { baseUrl, apiKey, username } = state.configuration;
+    getClient(baseUrl);
+    const basePath = baseUrl ? new URL(baseUrl).pathname : "/";
+    const [resolvedPath, resolvedoptions] = (0, import_util.expandReferences)(
+      state,
+      path,
+      options
+    );
+    const {
+      data,
+      headers = {
+        "content-type": "application/json",
+        "API-KEY": apiKey,
+        USERNAME: username
+      },
+      method = "POST",
+      query,
+      ...otherOptions
+    } = resolvedoptions;
+    const safePath = resolvedPath ? import_node_path.default.join(basePath, resolvedPath) : basePath;
+    const args = {
+      path: safePath,
+      data,
+      headers: {
+        ...headers
+      },
+      method,
+      query,
+      ...otherOptions
+    };
+    if (data) {
+      args.body = JSON.stringify(data);
+    }
+    const response = await client.request(args);
+    if (response.statusCode >= 400) {
+      await handleError(response, path);
+    }
+    (0, import_util.logResponse)(response);
+    return prepareNextState(state, response);
+  };
+};
+var handleError = async (response, path) => {
+  const error = await response.body.json();
+  if (response.statusCode === 404) {
+    (0, import_util.throwError)("NOT_FOUND", {
+      description: "The server returned an error, see details message",
+      error: error.message,
+      fix: `Kindly check the path: ${path} well and try again.`
+    });
+  }
+  if (response.statusCode === 403) {
+    (0, import_util.throwError)("FORBIDDEN", {
+      description: "The server returned an error, see details message",
+      error: error.message,
+      fix: `Make sure the API-Key,Username and senderid are correct and exists in the header of the request`
+    });
+  }
+};
+
+// src/mock.js
+var import_undici2 = require("undici");
+var wigalSmsResponse = {
+  status: "ACCEPTED",
+  message: "Message Accepted For Processing"
+};
+function createServer(url = "https://frogapi.wigal.com.gh") {
+  const agent = new import_undici2.MockAgent();
+  const mockPool = agent.get(url);
+  const sendSms2 = (req) => {
+    return {
+      statusCode: 200,
+      responseOptions: {
+        headers: { "Content-Type": "application/json" }
+      },
+      data: JSON.stringify(wigalSmsResponse)
+    };
+  };
+  mockPool.intercept({ method: "post", path: "/api/v3/sms/send" }).reply(sendSms2).persist();
+  return {
+    agent,
+    request: ({ method, path, data, ...rest }) => {
+      const opts = {
+        method,
+        path,
+        origin: url,
+        ...rest
+      };
+      if (data) {
+        opts.body = JSON.stringify(data);
+      }
+      return mockPool.request(opts);
+    }
+  };
+}
+
+// src/Adaptor.js
+var import_language_common3 = require("@openfn/language-common");
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null,
+    configuration: {}
+  };
+  return (state) => {
+    if (!state.configuration.baseUrl) {
+      const client2 = createServer();
+      setMockClient(client2);
+    }
+    return (0, import_language_common2.execute)(...operations)({ ...initialState, ...state });
+  };
+}
+function sendSms(data) {
+  return request("/api/v3/sms/send", {
+    method: "POST",
+    data
+  });
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cursor,
+  dataPath,
+  dataValue,
+  dateFns,
+  each,
+  execute,
+  field,
+  fields,
+  fn,
+  fnIf,
+  lastReferenceValue,
+  merge,
+  sendSms,
+  sourceValue
+});

package/dist/index.js

@@ -0,0 +1,210 @@
+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, {
+  cursor: () => cursor,
+  dataPath: () => dataPath,
+  dataValue: () => dataValue,
+  dateFns: () => dateFns,
+  each: () => each,
+  execute: () => execute,
+  field: () => field,
+  fields: () => fields,
+  fn: () => fn,
+  fnIf: () => fnIf,
+  lastReferenceValue: () => lastReferenceValue,
+  merge: () => merge,
+  sendSms: () => sendSms,
+  sourceValue: () => sourceValue
+});
+import { execute as commonExecute } from "@openfn/language-common";
+
+// src/util.js
+import undici from "undici";
+import nodepath from "path";
+import {
+  throwError,
+  logResponse,
+  expandReferences
+} from "@openfn/language-common/util";
+import { composeNextState } from "@openfn/language-common";
+var client;
+var getClient = (baseUrl) => {
+  if (baseUrl) {
+    const url = new URL(baseUrl);
+    client = new undici.Client(url.origin);
+  }
+  return client;
+};
+var setMockClient = (mockClient) => {
+  client = mockClient;
+};
+var prepareNextState = async (state, response) => {
+  const { body, ...responseWithoutBody } = response;
+  const result = await body.json();
+  if (!state.references) {
+    state.references = [];
+  }
+  const nextState = {
+    ...composeNextState(state, result),
+    response: responseWithoutBody
+  };
+  return nextState;
+};
+var request = (path, options) => {
+  return async (state) => {
+    const { baseUrl, apiKey, username } = state.configuration;
+    getClient(baseUrl);
+    const basePath = baseUrl ? new URL(baseUrl).pathname : "/";
+    const [resolvedPath, resolvedoptions] = expandReferences(
+      state,
+      path,
+      options
+    );
+    const {
+      data,
+      headers = {
+        "content-type": "application/json",
+        "API-KEY": apiKey,
+        USERNAME: username
+      },
+      method = "POST",
+      query,
+      ...otherOptions
+    } = resolvedoptions;
+    const safePath = resolvedPath ? nodepath.join(basePath, resolvedPath) : basePath;
+    const args = {
+      path: safePath,
+      data,
+      headers: {
+        ...headers
+      },
+      method,
+      query,
+      ...otherOptions
+    };
+    if (data) {
+      args.body = JSON.stringify(data);
+    }
+    const response = await client.request(args);
+    if (response.statusCode >= 400) {
+      await handleError(response, path);
+    }
+    logResponse(response);
+    return prepareNextState(state, response);
+  };
+};
+var handleError = async (response, path) => {
+  const error = await response.body.json();
+  if (response.statusCode === 404) {
+    throwError("NOT_FOUND", {
+      description: "The server returned an error, see details message",
+      error: error.message,
+      fix: `Kindly check the path: ${path} well and try again.`
+    });
+  }
+  if (response.statusCode === 403) {
+    throwError("FORBIDDEN", {
+      description: "The server returned an error, see details message",
+      error: error.message,
+      fix: `Make sure the API-Key,Username and senderid are correct and exists in the header of the request`
+    });
+  }
+};
+
+// src/mock.js
+import { MockAgent } from "undici";
+var wigalSmsResponse = {
+  status: "ACCEPTED",
+  message: "Message Accepted For Processing"
+};
+function createServer(url = "https://frogapi.wigal.com.gh") {
+  const agent = new MockAgent();
+  const mockPool = agent.get(url);
+  const sendSms2 = (req) => {
+    return {
+      statusCode: 200,
+      responseOptions: {
+        headers: { "Content-Type": "application/json" }
+      },
+      data: JSON.stringify(wigalSmsResponse)
+    };
+  };
+  mockPool.intercept({ method: "post", path: "/api/v3/sms/send" }).reply(sendSms2).persist();
+  return {
+    agent,
+    request: ({ method, path, data, ...rest }) => {
+      const opts = {
+        method,
+        path,
+        origin: url,
+        ...rest
+      };
+      if (data) {
+        opts.body = JSON.stringify(data);
+      }
+      return mockPool.request(opts);
+    }
+  };
+}
+
+// src/Adaptor.js
+import {
+  fn,
+  fnIf,
+  each,
+  merge,
+  field,
+  fields,
+  cursor,
+  dateFns,
+  dataPath,
+  dataValue,
+  sourceValue,
+  lastReferenceValue
+} from "@openfn/language-common";
+function execute(...operations) {
+  const initialState = {
+    references: [],
+    data: null,
+    configuration: {}
+  };
+  return (state) => {
+    if (!state.configuration.baseUrl) {
+      const client2 = createServer();
+      setMockClient(client2);
+    }
+    return commonExecute(...operations)({ ...initialState, ...state });
+  };
+}
+function sendSms(data) {
+  return request("/api/v3/sms/send", {
+    method: "POST",
+    data
+  });
+}
+
+// src/index.js
+var src_default = Adaptor_exports;
+export {
+  cursor,
+  dataPath,
+  dataValue,
+  dateFns,
+  src_default as default,
+  each,
+  execute,
+  field,
+  fields,
+  fn,
+  fnIf,
+  lastReferenceValue,
+  merge,
+  sendSms,
+  sourceValue
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@openfn/language-wigal-sms",
+  "version": "0.1.0",
+  "description": "OpenFn wigal-sms adaptor",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./types/index.d.ts",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "author": "Open Function Group",
+  "license": "LGPLv3",
+  "files": [
+    "dist/",
+    "types/",
+    "ast.json",
+    "configuration-schema.json"
+  ],
+  "dependencies": {
+    "undici": "^5.28.4",
+    "@openfn/language-common": "2.3.0"
+  },
+  "devDependencies": {
+    "assertion-error": "2.0.0",
+    "chai": "4.3.6",
+    "deep-eql": "4.1.1",
+    "esno": "^0.16.3",
+    "mocha": "^10.7.3",
+    "rimraf": "3.0.2"
+  },
+  "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 wigal-sms",
+    "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,73 @@
+/**
+ * SMS Request Object
+ * @typedef {Object} SMSRequestObject
+ * @public
+ * @property {string} senderid - The senderID used for sending message. Approved SenderIDs only
+ * @property {array} destinations - An array of objects containing the destination phone number and message to be sent
+ * @property {string} message - The message to be sent to the destinations
+ * @property {string} smstype - The type of message to be sent. Default is 'text'
+ */
+/**
+ * State object
+ * @typedef {Object} SendSMSState
+ * @property data - the parsed response body. containt status and message response
+ * @property response - the response from the Wigal SMS server, including headers, statusCode etc
+ * @property references - an array of all previous data objects used in the Job
+ **/
+/**
+ * Executes an operation.
+ * @function
+ * @private
+ * @param {Operation} operations - Operations
+ * @returns {State}
+ */
+export function execute(...operations: Operation): State;
+/**
+ * Send SMS using Wigal SMS Gateway API
+ *
+ * @example <caption>Send General SMS message</caption>
+ * sendSMS({
+ *   senderid: "Stevkky",
+ *   destinations: [{ destination: "0552825710" }],
+ *   message: "This is a sample message for SMS sending via Wigal FROG API.",
+ *   smstype: "text",
+ * });
+ * @example <caption>Send Personalized SMS message</caption>
+ * sendSMS({
+ *   senderid: "Stevkky",
+ *   destinations: [
+ *     {
+ *       destination: "0542709440",
+ *       message: "Hello Joe your order is ready",
+ *       msgid: "MGS1010101",
+ *       smstype: "text",
+ *     },
+ *   ],
+ * });
+ * @param {SMSRequestObject} data  - SMS payload to push to Wigal. This includes the message, phone number, etc
+ * @returns {Operation}
+ * @state {SendSMSState}
+ */
+export function sendSms(data: SMSRequestObject): Operation;
+/**
+ * SMS Request Object
+ */
+export type SMSRequestObject = any;
+/**
+ * State object
+ */
+export type SendSMSState = {
+    /**
+     * - the parsed response body. containt status and message response
+     */
+    data: any;
+    /**
+     * - the response from the Wigal SMS server, including headers, statusCode etc
+     */
+    response: any;
+    /**
+     * - an array of all previous data objects used in the Job
+     */
+    references: any;
+};
+export { fn, fnIf, each, merge, field, fields, cursor, dateFns, dataPath, dataValue, sourceValue, 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";

package/types/mock.d.ts

@@ -0,0 +1,10 @@
+export function createServer(url?: string): {
+    agent: MockAgent<MockAgent.Options>;
+    request: ({ method, path, data, ...rest }: {
+        [x: string]: any;
+        method: any;
+        path: any;
+        data: any;
+    }) => Promise<import("undici/types/dispatcher").default.ResponseData>;
+};
+import { MockAgent } from "undici/types";

package/types/util.d.ts

@@ -0,0 +1,4 @@
+export function setMockClient(mockClient: any): void;
+export function prepareNextState(state: any, response: any): Promise<any>;
+export function request(path: any, options: any): (state: any) => Promise<any>;
+export function handleError(response: any, path: any): Promise<void>;