@suprsend/node-sdk 0.0.6 → 0.1.0

package/dist/request_json/event.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "http://github.com/suprsend/suprsend-node-sdk/request_json/event.json",
+  "title": "track_event",
+  "description": "Json schema for Track event",
+  "$comment": "Json schema for Track event",
+  "type": "object",
+  "properties": {
+    "$insert_id": {
+      "type": "string",
+      "minLength": 36,
+      "description": "unique uuid generated per request"
+    },
+    "$time": {
+      "type": "integer",
+      "minimum": 1640995200000,
+      "description": "Timestamp: unix epoch in milliseconds"
+    },
+    "event": {
+      "type": "string",
+      "minLength": 2,
+      "description": "Event Name to track"
+    },
+    "env": {
+      "type": "string",
+      "minLength": 20,
+      "description": "Workspace key"
+    },
+    "distinct_id": {
+      "type": "string",
+      "minLength": 1,
+      "description": "distinct_id: Id which uniquely identify a user in your app"
+    },
+    "properties": {
+      "type": "object",
+      "description": "Properties related to event"
+    }
+  },
+  "required": [
+    "$insert_id",
+    "$time",
+    "event",
+    "env",
+    "distinct_id",
+    "properties"
+  ]
+}

package/dist/request_json/workflow.json

@@ -27,7 +27,11 @@
       "$ref": "#/definitions/non_empty_string",
       "description": "timestamp in ISO-8601 format. e.g 2021-08-27T20:14:51.643Z"
     },
-    "priority_algorithm": { "type": "boolean" },
+    "delivery": {
+      "type": "object",
+      "$ref": "#/definitions/delivery_setting",
+      "description": "set parameters e.g smart (true/false), success metric, TTL, mandatory channels etc"
+    },
     "users": {
       "type": "array",
       "items": { "$ref": "#/definitions/user_setting" },
@@ -51,7 +55,7 @@
       "minLength": 8,
       "pattern": "^\\+[0-9\\s]+",
       "message": {
-        "required": "Either a mobile-number or an array of mobile-numbers. e.g [\"41446681800\"]",
+        "required": "Either a mobile-number or an array of mobile-numbers. e.g [\"+41446681800\"]",
         "pattern": "number must start with + and must contain country code. e.g. +41446681800"
       }
     },
@@ -70,7 +74,11 @@
     "user_setting": {
       "type": "object",
       "properties": {
-        "distinct_id": { "$ref": "#/definitions/non_empty_string" },
+        "distinct_id": {
+          "type": "string",
+          "minLength": 1,
+          "description": "distinct_id: Id which uniquely identify a user in your app"
+        },
         "$email": {
           "oneOf": [
             { "$ref": "#/definitions/email_pattern" },
@@ -170,6 +178,44 @@
       },
       "required": ["distinct_id"],
       "additionalProperties": false
+    },
+    "delivery_setting": {
+      "type": "object",
+      "properties": {
+        "smart": {
+          "type": "boolean",
+          "default": false,
+          "description": "If false, notifications are sent to all channels at once. If true, notifications are sent one-by-one until success metric is satisfied"
+        },
+        "success": {
+          "type": "string",
+          "default": "seen",
+          "description": "possible values: seen/interaction/<user_defined_event>."
+        },
+        "time_to_live": {
+          "type": "string",
+          "default": "1h",
+          "description": "Used if smart=true. format [XX]d[XX]h[XX]m[XX]s e.g 1d2h30m10s(for 1day 2hours 30minutes 10sec)"
+        },
+        "mandatory_channels": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "androidpush",
+              "iospush",
+              "webpush",
+              "email",
+              "sms",
+              "whatsapp"
+            ]
+          },
+          "minItems": 0,
+          "description": "e.g ['email', 'sms']. Used if smart=true, notification on these channels must be sent, independent of success metric outcome"
+        }
+      },
+      "required": [],
+      "additionalProperties": false
     }
   }
 }

package/dist/signature.js

@@ -19,7 +19,7 @@ function get_request_signature(url, http_verb, content, headers, secret) {
     return "";
   }
 
-  var content_md5 = _crypto["default"].createHash("md5").update(JSON.stringify(content)).digest("hex");
+  var content_md5 = _crypto["default"].createHash("md5").update(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;

package/dist/utils.js

@@ -6,9 +6,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SuprsendError = void 0;
-exports._get_schema = _get_schema;
 exports.base64Encode = base64Encode;
+exports.epoch_milliseconds = epoch_milliseconds;
+exports.has_special_char = void 0;
+exports.is_empty = is_empty;
+exports.is_object = is_object;
+exports.is_string = is_string;
 exports.resolveTilde = resolveTilde;
+exports.uuid = uuid;
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
@@ -24,204 +31,12 @@ var _os = _interopRequireDefault(require("os"));
 
 var _fs = _interopRequireDefault(require("fs"));
 
-var _path = _interopRequireDefault(require("path"));
+var _uuid = require("uuid");
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
-var schema = {
-  $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"
-      },
-      minItems: 1,
-      maxItems: 100,
-      description: "user object to run workflow for. At least 1 user is required"
-    },
-    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: 2
-    },
-    mobile_number_pattern: {
-      type: "string",
-      minLength: 8,
-      pattern: "^\\+[0-9\\s]+",
-      message: {
-        required: 'Either a mobile-number or an array of mobile-numbers. e.g ["41446681800"]',
-        pattern: "number must start with + and must contain country code. e.g. +41446681800"
-      }
-    },
-    email_pattern: {
-      type: "string",
-      format: "email",
-      pattern: "^\\S+@\\S+\\.\\S+$",
-      description: "email of an user",
-      minLength: 6,
-      maxLength: 127,
-      message: {
-        required: "",
-        pattern: "value in email format required. e.g. user@example.com"
-      }
-    },
-    user_setting: {
-      type: "object",
-      properties: {
-        distinct_id: {
-          $ref: "#/definitions/non_empty_string"
-        },
-        $email: {
-          oneOf: [{
-            $ref: "#/definitions/email_pattern"
-          }, {
-            type: "array",
-            uniqueItems: true,
-            maxItems: 10,
-            minItems: 1,
-            items: {
-              $ref: "#/definitions/email_pattern"
-            }
-          }]
-        },
-        $sms: {
-          oneOf: [{
-            $ref: "#/definitions/mobile_number_pattern"
-          }, {
-            type: "array",
-            uniqueItems: true,
-            maxItems: 10,
-            minItems: 1,
-            items: {
-              $ref: "#/definitions/mobile_number_pattern"
-            }
-          }]
-        },
-        $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/mobile_number_pattern"
-          }, {
-            type: "array",
-            uniqueItems: true,
-            maxItems: 10,
-            minItems: 1,
-            items: {
-              $ref: "#/definitions/mobile_number_pattern"
-            }
-          }]
-        },
-        $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
-    }
-  }
-};
-
 function base64Encode(file) {
   var body = _fs["default"].readFileSync(file);
 
@@ -240,35 +55,6 @@ function resolveTilde(filePath) {
   return filePath;
 }
 
-var __JSON_SCHEMAS = {};
-
-function _get_schema(schema_name) {
-  var schema_body = __JSON_SCHEMAS[schema_name];
-
-  if (!schema_body) {
-    schema_body = schema;
-    __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 SuprsendError("Missing Schema");
-  }
-
-  return json_schema;
-}
-
 var SuprsendError = /*#__PURE__*/function (_Error) {
   (0, _inherits2["default"])(SuprsendError, _Error);
 
@@ -286,4 +72,36 @@ var SuprsendError = /*#__PURE__*/function (_Error) {
   return SuprsendError;
 }( /*#__PURE__*/(0, _wrapNativeSuper2["default"])(Error));
 
-exports.SuprsendError = SuprsendError;
+exports.SuprsendError = SuprsendError;
+
+function is_string(value) {
+  return typeof value === "string";
+}
+
+function is_object(value) {
+  return (0, _typeof2["default"])(value) === "object" && !Array.isArray(value) && value !== null;
+}
+
+function is_empty(value) {
+  if (is_object(value)) {
+    return Object.keys(value) <= 0;
+  } else if (Array.isArray(value)) {
+    return value.length <= 0;
+  }
+}
+
+var has_special_char = function has_special_char(str) {
+  var _str$toLowerCase;
+
+  return str.startsWith("$") || (str === null || str === void 0 ? void 0 : (_str$toLowerCase = str.toLowerCase()) === null || _str$toLowerCase === void 0 ? void 0 : _str$toLowerCase.startsWith("ss_"));
+};
+
+exports.has_special_char = has_special_char;
+
+function uuid() {
+  return (0, _uuid.v4)();
+}
+
+function epoch_milliseconds() {
+  return Math.round(Date.now());
+}

package/dist/workflow.js

@@ -23,6 +23,8 @@ var _utils = require("./utils");
 
 var _axios = _interopRequireDefault(require("axios"));
 
+var workflow_schema = require("./request_json/workflow.json");
+
 var Workflow = /*#__PURE__*/function () {
   function Workflow(ss_instance, data) {
     (0, _classCallCheck2["default"])(this, Workflow);
@@ -69,7 +71,7 @@ var Workflow = /*#__PURE__*/function () {
                 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);
+                  signature = (0, _signature["default"])(this.url, "POST", content_text, headers, this.ss_instance.env_secret);
                   headers["Authorization"] = "".concat(this.ss_instance.env_key, ":").concat(signature);
                 }
 
@@ -123,7 +125,7 @@ var Workflow = /*#__PURE__*/function () {
         throw new _utils.SuprsendError("data must be a object");
       }
 
-      var schema = (0, _utils._get_schema)("workflow");
+      var schema = workflow_schema;
       var v = new _jsonschema.Validator();
       var validated_data = v.validate(this.data, schema);
 

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@suprsend/node-sdk",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "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/",
+    "build": "rm -rf dist && babel ./src --out-dir dist && mkdir ./dist/request_json && cp -R ./src/request_json/ ./dist/request_json/",
     "publish_sdk": "npm run build && npm publish"
   },
   "keywords": [
     "suprsend-node-sdk",
     "workflow"
   ],
-  "author": "Sivaram Katta",
+  "author": "SuprSend Developers",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,7 +24,8 @@
     "@babel/runtime": "^7.16.3",
     "axios": "^0.24.0",
     "jsonschema": "^1.4.0",
-    "mime-types": "^2.1.34"
+    "mime-types": "^2.1.34",
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
     "@babel/cli": "^7.16.0",

package/src/event.js

@@ -0,0 +1,148 @@
+import {
+  is_object,
+  is_string,
+  SuprsendError,
+  has_special_char,
+  uuid,
+  epoch_milliseconds,
+} from "./utils";
+import get_request_signature from "./signature";
+import { Validator } from "jsonschema";
+import axios from "axios";
+
+const event_schema = require("./request_json/event.json");
+
+const RESERVED_EVENT_NAMES = [
+  "$identify",
+  "$notification_delivered",
+  "$notification_dismiss",
+  "$notification_clicked",
+  "$app_launched",
+  "$user_login",
+  "$user_logout",
+];
+
+class EventCollector {
+  constructor(config) {
+    this.config = config;
+    this.__url = this.__get_url();
+    this.__headers = this.__common_headers();
+    this.__supr_props = this.__super_properties();
+  }
+
+  __get_url() {
+    let url_template = "event/";
+    if (this.config.include_signature_param) {
+      if (this.config.auth_enabled) {
+        url_template = url_template + "?verify=true";
+      } else {
+        url_template = url_template + "?verify=false";
+      }
+    }
+    return `${this.config.base_url}${url_template}`;
+  }
+
+  __common_headers() {
+    return {
+      "Content-Type": "application/json; charset=utf-8",
+      "User-Agent": this.config.user_agent,
+    };
+  }
+  __dynamic_headers() {
+    return {
+      Date: new Date().toUTCString(),
+    };
+  }
+
+  __super_properties() {
+    return {
+      $ss_sdk_version: this.config.user_agent,
+    };
+  }
+
+  __check_event_prefix(event_name) {
+    if (!RESERVED_EVENT_NAMES.includes(event_name)) {
+      if (has_special_char(event_name)) {
+        throw new SuprsendError(
+          "event_names starting with [$,ss_] are reserved"
+        );
+      }
+    }
+  }
+
+  __validate_event_name(event_name) {
+    if (!is_string(event_name)) {
+      throw new SuprsendError("event_name must be a string");
+    }
+    event_name = event_name.trim();
+    this.__check_event_prefix(event_name);
+    return event_name;
+  }
+
+  validate_track_event_schema(data) {
+    if (!data["properties"]) {
+      data["properties"] = {};
+    }
+    const schema = event_schema;
+    var v = new Validator();
+    const validated_data = v.validate(data, schema);
+    if (validated_data.valid) {
+      return data;
+    } else {
+      const error_obj = validated_data.errors[0];
+      const error_msg = `${error_obj.property} ${error_obj.message}`;
+      throw new SuprsendError(error_msg);
+    }
+  }
+
+  collect(distinct_id, event_name, properties = {}) {
+    event_name = this.__validate_event_name(event_name);
+    if (!is_object(properties)) {
+      throw new SuprsendError("properties must be a dictionary");
+    }
+    properties = { ...properties, ...this.__supr_props };
+    let event = {
+      $insert_id: uuid(),
+      $time: epoch_milliseconds(),
+      event: event_name,
+      env: this.config.env_key,
+      distinct_id: distinct_id,
+      properties: properties,
+    };
+    event = this.validate_track_event_schema(event);
+    return this.send(event);
+  }
+
+  async send(event) {
+    const headers = { ...this.__headers, ...this.__dynamic_headers() };
+    const content_text = JSON.stringify(event);
+    if (this.config.auth_enabled) {
+      const signature = get_request_signature(
+        this.__url,
+        "POST",
+        content_text,
+        headers,
+        this.config.env_secret
+      );
+      headers["Authorization"] = `${this.config.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,
+      };
+    }
+  }
+}
+
+export default EventCollector;