@suprsend/node-sdk 0.0.1

package/.babelrc

@@ -0,0 +1,4 @@
+{
+  "presets": ["@babel/preset-env"],
+  "plugins": [["@babel/transform-runtime"]]
+}

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "editor.formatOnSave": true
+}

package/dist/config.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var config = {
+  staging: "https://collector-staging.suprsend.workers.dev/",
+  prod: "https://hub.suprsend.com/"
+};
+var _default = config;
+exports["default"] = _default;

package/dist/index.js

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _config = _interopRequireDefault(require("./config"));
+
+var _workflow = _interopRequireDefault(require("./workflow"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _mimeTypes = _interopRequireDefault(require("mime-types"));
+
+var _utils = require("./utils");
+
+var package_json = require("../package.json");
+
+var Suprsend = /*#__PURE__*/function () {
+  function Suprsend(workspace_env, workspace_secret) {
+    var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    (0, _classCallCheck2["default"])(this, Suprsend);
+    this.env_key = workspace_env;
+    this.env_secret = workspace_secret;
+    this.config = config;
+    this.base_url = this._get_url(config.base_url);
+    this.auth_enabled = config.auth_enabled !== false;
+    this.include_signature_param = config.include_signature_param !== false;
+    this.user_agent = "suprsend/".concat(package_json.version, ";node/").concat(process.version.slice(1));
+
+    this._validate();
+  }
+
+  (0, _createClass2["default"])(Suprsend, [{
+    key: "_validate",
+    value: function _validate() {
+      if (!this.env_key) {
+        throw new Error("SuprsendError: Missing Mandatory WORKSPACE_ENVIRONEMENT");
+      } else if (!this.env_secret) {
+        throw new Error("SuprsendError: Missing Mandatory WORKSPACE_SECRET");
+      } else if (!this.base_url) {
+        throw new Error("SuprsendError: Missing Mandatory base url");
+      }
+    }
+  }, {
+    key: "_get_url",
+    value: function _get_url(base_url) {
+      if (base_url) {
+        base_url = base_url.trim();
+      }
+
+      if (!base_url) {
+        if (this.config.is_staging) {
+          base_url = _config["default"].staging;
+        } else {
+          base_url = _config["default"].prod;
+        }
+      }
+
+      base_url = base_url.trim();
+
+      if (!base_url.endsWith("/")) {
+        base_url += "/";
+      }
+
+      return base_url;
+    }
+  }, {
+    key: "add_attachment",
+    value: function add_attachment(body, file_path) {
+      if (!body.data) {
+        body.data = {};
+      }
+
+      if (!body.data instanceof Object) {
+        throw new Error("SuprsendError: data must be an object");
+      }
+
+      var attachment = this._get_attachment_json_for_file(file_path);
+
+      if (!body.data["$attachments"]) {
+        body["data"]["$attachments"] = [];
+      }
+
+      body["data"]["$attachments"].push(attachment);
+      return body;
+    }
+  }, {
+    key: "_get_attachment_json_for_file",
+    value: function _get_attachment_json_for_file(file_path) {
+      var abs_path = _path["default"].resolve((0, _utils.resolveTilde)(file_path));
+
+      return {
+        filename: _path["default"].basename(abs_path),
+        contentType: _mimeTypes["default"].lookup(abs_path),
+        data: (0, _utils.base64Encode)(abs_path)
+      };
+    }
+  }, {
+    key: "trigger_workflow",
+    value: function trigger_workflow(data) {
+      var wf = new _workflow["default"](this, data);
+      wf.validate_data();
+      return wf.execute_workflow();
+    }
+  }]);
+  return Suprsend;
+}();
+
+var _default = Suprsend;
+exports["default"] = _default;

package/dist/request_json/workflow.json

@@ -0,0 +1,192 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "http://github.com/suprsend/suprsend-node-sdk/request_json/workflow.json",
+  "title": "workflow_request",
+  "description": "Json schema for workflow request",
+  "$comment": "Json schema for workflow request",
+  "type": "object",
+  "properties": {
+    "name": {
+      "$ref": "#/definitions/non_empty_string",
+      "description": "name of workflow"
+    },
+    "template": {
+      "$ref": "#/definitions/non_empty_string",
+      "description": "slug of Template"
+    },
+    "notification_category": {
+      "$ref": "#/definitions/non_empty_string",
+      "description": "slug of Notification category"
+    },
+    "delay": {
+      "type": ["string", "integer"],
+      "minimum": 0,
+      "description": "If string: format [XX]d[XX]h[XX]m[XX]s e.g 1d2h30m10s(for 1day 2hours 30minutes 10sec). If integer: value in number of seconds"
+    },
+    "trigger_at": {
+      "$ref": "#/definitions/non_empty_string",
+      "description": "timestamp in ISO-8601 format. e.g 2021-08-27T20:14:51.643Z"
+    },
+    "priority_algorithm": {
+      "type": "boolean"
+    },
+    "users": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/user_setting"
+      },
+      "description": "user object to run workflow for"
+    },
+    "data": {
+      "type": "object",
+      "description": "variables to be used in workflow. e.g replacing templates variables."
+    }
+  },
+  "required": ["name", "template", "notification_category", "users", "data"],
+  "definitions": {
+    "non_empty_string": {
+      "type": "string",
+      "minLength": 1
+    },
+    "user_setting": {
+      "type": "object",
+      "properties": {
+        "distinct_id": {
+          "$ref": "#/definitions/non_empty_string"
+        },
+        "$email": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$sms": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$androidpush": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$iospush": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$whatsapp": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$webpush": {
+          "oneOf": [
+            {
+              "type": "object",
+              "minProperties": 1
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "type": "object",
+                "minProperties": 1
+              }
+            }
+          ]
+        },
+        "$inbox": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$messenger": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        }
+      },
+      "required": ["distinct_id"],
+      "additionalProperties": false
+    }
+  }
+}

package/dist/signature.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = get_request_signature;
+
+var _crypto = _interopRequireDefault(require("crypto"));
+
+function get_path(url) {
+  var url_info = new URL(url);
+  return url_info.pathname + url_info.search;
+}
+
+function get_request_signature(url, http_verb, content, headers, secret) {
+  if (http_verb === "GET") {
+    return "";
+  }
+
+  var content_md5 = _crypto["default"].createHash("md5").update(JSON.stringify(content)).digest("hex");
+
+  var request_uri = get_path(url);
+  var sign_string = http_verb + "\n" + content_md5 + "\n" + headers["Content-Type"] + "\n" + headers["Date"] + "\n" + request_uri;
+
+  var hash = _crypto["default"].createHmac("sha256", secret).update(sign_string);
+
+  return hash.digest("base64");
+}

package/dist/utils.js

@@ -0,0 +1,63 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._get_schema = _get_schema;
+exports.base64Encode = base64Encode;
+exports.resolveTilde = resolveTilde;
+
+var _os = _interopRequireDefault(require("os"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _path = _interopRequireDefault(require("path"));
+
+function base64Encode(file) {
+  var body = _fs["default"].readFileSync(file);
+
+  return body.toString("base64");
+}
+
+function resolveTilde(filePath) {
+  if (!filePath || typeof filePath !== "string") {
+    return "";
+  }
+
+  if (filePath.startsWith("~/") || filePath === "~") {
+    return filePath.replace("~", _os["default"].homedir());
+  }
+
+  return filePath;
+}
+
+var __JSON_SCHEMAS = {};
+
+function _get_schema(schema_name) {
+  var schema_body = __JSON_SCHEMAS[schema_name];
+
+  if (!schema_body) {
+    schema_body = _load_json_schema(schema_name);
+    __JSON_SCHEMAS[schema_name] = schema_body;
+  }
+
+  return schema_body;
+}
+
+function _load_json_schema(schema_name) {
+  var file_path = _path["default"].join(__dirname, "request_json/".concat(schema_name, ".json"));
+
+  var json_schema;
+
+  try {
+    var schema_string = _fs["default"].readFileSync(file_path, "utf8");
+
+    json_schema = JSON.parse(schema_string);
+  } catch (e) {
+    throw new Error("SuprsendError: Missing Schema");
+  }
+
+  return json_schema;
+}

package/dist/workflow.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _signature = _interopRequireDefault(require("./signature"));
+
+var _https = _interopRequireDefault(require("https"));
+
+var _jsonschema = require("jsonschema");
+
+var _utils = require("./utils");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var Workflow = /*#__PURE__*/function () {
+  function Workflow(ss_instance, data) {
+    (0, _classCallCheck2["default"])(this, Workflow);
+    this.ss_instance = ss_instance;
+    this.data = data;
+    this.url = this._get_url();
+  }
+
+  (0, _createClass2["default"])(Workflow, [{
+    key: "_get_url",
+    value: function _get_url() {
+      var url_template = "/trigger/";
+
+      if (this.ss_instance.include_signature_param) {
+        if (this.ss_instance.auth_enabled) {
+          url_template = url_template + "?verify=true";
+        } else {
+          url_template = url_template + "?verify=false";
+        }
+      }
+
+      var url_formatted = "".concat(this.ss_instance.base_url).concat(this.ss_instance.env_key).concat(url_template);
+      return url_formatted;
+    }
+  }, {
+    key: "_get_headers",
+    value: function _get_headers() {
+      return {
+        "Content-Type": "application/json",
+        Date: new Date().toUTCString(),
+        "User-Agent": this.ss_instance.user_agent
+      };
+    }
+  }, {
+    key: "execute_workflow",
+    value: function () {
+      var _execute_workflow = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var headers, content_text, signature, response;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                headers = this._get_headers();
+                content_text = JSON.stringify(this.data);
+
+                if (this.ss_instance.auth_enabled) {
+                  signature = (0, _signature["default"])(this.url, "POST", this.data, headers, this.ss_instance.env_secret);
+                  headers["Authorization"] = "".concat(this.ss_instance.env_key, ":").concat(signature);
+                }
+
+                _context.prev = 3;
+                _context.next = 6;
+                return _axios["default"].post(this.url, content_text, {
+                  headers: headers
+                });
+
+              case 6:
+                response = _context.sent;
+                return _context.abrupt("return", {
+                  status_code: response.status,
+                  success: true,
+                  message: response.statusText
+                });
+
+              case 10:
+                _context.prev = 10;
+                _context.t0 = _context["catch"](3);
+                return _context.abrupt("return", {
+                  status_code: 400,
+                  success: false,
+                  message: _context.t0.message
+                });
+
+              case 13:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[3, 10]]);
+      }));
+
+      function execute_workflow() {
+        return _execute_workflow.apply(this, arguments);
+      }
+
+      return execute_workflow;
+    }()
+  }, {
+    key: "validate_data",
+    value: function validate_data() {
+      var _this$data;
+
+      if (!((_this$data = this.data) !== null && _this$data !== void 0 && _this$data.data)) {
+        this.data.data = {};
+      }
+
+      if (!(this.data.data instanceof Object)) {
+        throw new Error("SuprsendError: data must be a object");
+      }
+
+      var schema = (0, _utils._get_schema)("workflow");
+
+      try {
+        var v = new _jsonschema.Validator();
+        v.validate(this.data, schema);
+      } catch (e) {
+        if (e instanceof _jsonschema.SchemaError) {
+          throw new Error("SuprsendSchemaError:".concat(e.message));
+        } else if (e instanceof _jsonschema.ValidationError) {
+          throw new Error("SuprsendValidationError:".concat(e.message));
+        }
+      }
+
+      return this.data;
+    }
+  }]);
+  return Workflow;
+}();
+
+var _default = Workflow;
+exports["default"] = _default;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@suprsend/node-sdk",
+  "version": "0.0.1",
+  "description": "Suprsend Node SDK to trigger workflow from backend",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "rm -rf dist && babel ./src --out-dir dist && mkdir ./dist/request_json && cp ./src/request_json/workflow.json ./dist/request_json/"
+  },
+  "keywords": [
+    "suprsend-node-sdk",
+    "workflow"
+  ],
+  "author": "Sivaram Katta",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/suprsend/suprsend-node-sdk.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.16.3",
+    "axios": "^0.24.0",
+    "jsonschema": "^1.4.0",
+    "mime-types": "^2.1.34"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.0",
+    "@babel/plugin-transform-runtime": "^7.16.4",
+    "@babel/preset-env": "^7.16.4"
+  }
+}

package/src/config.js

@@ -0,0 +1,6 @@
+const config = {
+  staging: "https://collector-staging.suprsend.workers.dev/",
+  prod: "https://hub.suprsend.com/",
+};
+
+export default config;

package/src/index.js

@@ -0,0 +1,84 @@
+import config from "./config";
+import Workflow from "./workflow";
+import path from "path";
+import mime from "mime-types";
+import { base64Encode, resolveTilde } from "./utils";
+
+const package_json = require("../package.json");
+
+class Suprsend {
+  constructor(workspace_env, workspace_secret, config = {}) {
+    this.env_key = workspace_env;
+    this.env_secret = workspace_secret;
+    this.config = config;
+    this.base_url = this._get_url(config.base_url);
+    this.auth_enabled = config.auth_enabled !== false;
+    this.include_signature_param = config.include_signature_param !== false;
+    this.user_agent = `suprsend/${
+      package_json.version
+    };node/${process.version.slice(1)}`;
+    this._validate();
+  }
+
+  _validate() {
+    if (!this.env_key) {
+      throw new Error(
+        "SuprsendError: Missing Mandatory WORKSPACE_ENVIRONEMENT"
+      );
+    } else if (!this.env_secret) {
+      throw new Error("SuprsendError: Missing Mandatory WORKSPACE_SECRET");
+    } else if (!this.base_url) {
+      throw new Error("SuprsendError: Missing Mandatory base url");
+    }
+  }
+
+  _get_url(base_url) {
+    if (base_url) {
+      base_url = base_url.trim();
+    }
+    if (!base_url) {
+      if (this.config.is_staging) {
+        base_url = config.staging;
+      } else {
+        base_url = config.prod;
+      }
+    }
+    base_url = base_url.trim();
+    if (!base_url.endsWith("/")) {
+      base_url += "/";
+    }
+    return base_url;
+  }
+
+  add_attachment(body, file_path) {
+    if (!body.data) {
+      body.data = {};
+    }
+    if (!body.data instanceof Object) {
+      throw new Error("SuprsendError: data must be an object");
+    }
+    const attachment = this._get_attachment_json_for_file(file_path);
+    if (!body.data["$attachments"]) {
+      body["data"]["$attachments"] = [];
+    }
+    body["data"]["$attachments"].push(attachment);
+    return body;
+  }
+
+  _get_attachment_json_for_file(file_path) {
+    const abs_path = path.resolve(resolveTilde(file_path));
+    return {
+      filename: path.basename(abs_path),
+      contentType: mime.lookup(abs_path),
+      data: base64Encode(abs_path),
+    };
+  }
+
+  trigger_workflow(data) {
+    const wf = new Workflow(this, data);
+    wf.validate_data();
+    return wf.execute_workflow();
+  }
+}
+
+export default Suprsend;

package/src/request_json/workflow.json

@@ -0,0 +1,192 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "http://github.com/suprsend/suprsend-node-sdk/request_json/workflow.json",
+  "title": "workflow_request",
+  "description": "Json schema for workflow request",
+  "$comment": "Json schema for workflow request",
+  "type": "object",
+  "properties": {
+    "name": {
+      "$ref": "#/definitions/non_empty_string",
+      "description": "name of workflow"
+    },
+    "template": {
+      "$ref": "#/definitions/non_empty_string",
+      "description": "slug of Template"
+    },
+    "notification_category": {
+      "$ref": "#/definitions/non_empty_string",
+      "description": "slug of Notification category"
+    },
+    "delay": {
+      "type": ["string", "integer"],
+      "minimum": 0,
+      "description": "If string: format [XX]d[XX]h[XX]m[XX]s e.g 1d2h30m10s(for 1day 2hours 30minutes 10sec). If integer: value in number of seconds"
+    },
+    "trigger_at": {
+      "$ref": "#/definitions/non_empty_string",
+      "description": "timestamp in ISO-8601 format. e.g 2021-08-27T20:14:51.643Z"
+    },
+    "priority_algorithm": {
+      "type": "boolean"
+    },
+    "users": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/user_setting"
+      },
+      "description": "user object to run workflow for"
+    },
+    "data": {
+      "type": "object",
+      "description": "variables to be used in workflow. e.g replacing templates variables."
+    }
+  },
+  "required": ["name", "template", "notification_category", "users", "data"],
+  "definitions": {
+    "non_empty_string": {
+      "type": "string",
+      "minLength": 1
+    },
+    "user_setting": {
+      "type": "object",
+      "properties": {
+        "distinct_id": {
+          "$ref": "#/definitions/non_empty_string"
+        },
+        "$email": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$sms": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$androidpush": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$iospush": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$whatsapp": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$webpush": {
+          "oneOf": [
+            {
+              "type": "object",
+              "minProperties": 1
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "type": "object",
+                "minProperties": 1
+              }
+            }
+          ]
+        },
+        "$inbox": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        },
+        "$messenger": {
+          "oneOf": [
+            {
+              "$ref": "#/definitions/non_empty_string"
+            },
+            {
+              "type": "array",
+              "uniqueItems": true,
+              "maxItems": 10,
+              "minItems": 1,
+              "items": {
+                "$ref": "#/definitions/non_empty_string"
+              }
+            }
+          ]
+        }
+      },
+      "required": ["distinct_id"],
+      "additionalProperties": false
+    }
+  }
+}

package/src/signature.js

@@ -0,0 +1,35 @@
+import crypto from "crypto";
+
+function get_path(url) {
+  const url_info = new URL(url);
+  return url_info.pathname + url_info.search;
+}
+
+export default function get_request_signature(
+  url,
+  http_verb,
+  content,
+  headers,
+  secret
+) {
+  if (http_verb === "GET") {
+    return "";
+  }
+  const content_md5 = crypto
+    .createHash("md5")
+    .update(JSON.stringify(content))
+    .digest("hex");
+  const request_uri = get_path(url);
+  const sign_string =
+    http_verb +
+    "\n" +
+    content_md5 +
+    "\n" +
+    headers["Content-Type"] +
+    "\n" +
+    headers["Date"] +
+    "\n" +
+    request_uri;
+  const hash = crypto.createHmac("sha256", secret).update(sign_string);
+  return hash.digest("base64");
+}

package/src/utils.js

@@ -0,0 +1,43 @@
+import os from "os";
+import fs from "fs";
+import path from "path";
+
+export function base64Encode(file) {
+  var body = fs.readFileSync(file);
+  return body.toString("base64");
+}
+
+export function resolveTilde(filePath) {
+  if (!filePath || typeof filePath !== "string") {
+    return "";
+  }
+
+  if (filePath.startsWith("~/") || filePath === "~") {
+    return filePath.replace("~", os.homedir());
+  }
+
+  return filePath;
+}
+
+let __JSON_SCHEMAS = {};
+
+export function _get_schema(schema_name) {
+  var schema_body = __JSON_SCHEMAS[schema_name];
+  if (!schema_body) {
+    schema_body = _load_json_schema(schema_name);
+    __JSON_SCHEMAS[schema_name] = schema_body;
+  }
+  return schema_body;
+}
+
+function _load_json_schema(schema_name) {
+  var file_path = path.join(__dirname, `request_json/${schema_name}.json`);
+  var json_schema;
+  try {
+    var schema_string = fs.readFileSync(file_path, "utf8");
+    json_schema = JSON.parse(schema_string);
+  } catch (e) {
+    throw new Error("SuprsendError: Missing Schema");
+  }
+  return json_schema;
+}

package/src/workflow.js

@@ -0,0 +1,86 @@
+import get_request_signature from "./signature";
+import https from "https";
+import { Validator, SchemaError, ValidationError } from "jsonschema";
+import { _get_schema } from "./utils";
+import axios from "axios";
+
+class Workflow {
+  constructor(ss_instance, data) {
+    this.ss_instance = ss_instance;
+    this.data = data;
+    this.url = this._get_url();
+  }
+
+  _get_url() {
+    let url_template = "/trigger/";
+    if (this.ss_instance.include_signature_param) {
+      if (this.ss_instance.auth_enabled) {
+        url_template = url_template + "?verify=true";
+      } else {
+        url_template = url_template + "?verify=false";
+      }
+    }
+    const url_formatted = `${this.ss_instance.base_url}${this.ss_instance.env_key}${url_template}`;
+    return url_formatted;
+  }
+
+  _get_headers() {
+    return {
+      "Content-Type": "application/json",
+      Date: new Date().toUTCString(),
+      "User-Agent": this.ss_instance.user_agent,
+    };
+  }
+
+  async execute_workflow() {
+    const headers = this._get_headers();
+    const content_text = JSON.stringify(this.data);
+    if (this.ss_instance.auth_enabled) {
+      const signature = get_request_signature(
+        this.url,
+        "POST",
+        this.data,
+        headers,
+        this.ss_instance.env_secret
+      );
+      headers["Authorization"] = `${this.ss_instance.env_key}:${signature}`;
+    }
+    try {
+      const response = await axios.post(this.url, content_text, { headers });
+      return {
+        status_code: response.status,
+        success: true,
+        message: response.statusText,
+      };
+    } catch (err) {
+      return {
+        status_code: 400,
+        success: false,
+        message: err.message,
+      };
+    }
+  }
+
+  validate_data() {
+    if (!this.data?.data) {
+      this.data.data = {};
+    }
+    if (!(this.data.data instanceof Object)) {
+      throw new Error("SuprsendError: data must be a object");
+    }
+    const schema = _get_schema("workflow");
+    try {
+      var v = new Validator();
+      v.validate(this.data, schema);
+    } catch (e) {
+      if (e instanceof SchemaError) {
+        throw new Error(`SuprsendSchemaError:${e.message}`);
+      } else if (e instanceof ValidationError) {
+        throw new Error(`SuprsendValidationError:${e.message}`);
+      }
+    }
+    return this.data;
+  }
+}
+
+export default Workflow;