@coherentglobal/spark-execute-sdk 0.3.0

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@coherentglobal/spark-execute-sdk",
+  "version": "0.3.0",
+  "description": "",
+  "mains": "index.js",
+  "browser": "dist/browser.js",
+  "scripts": {
+    "build:types": "tsc --declaration",
+    "bundle:full": "browserify src/browser.js  --standalone Spark > dist/browser.js",
+    "bundle:min": "browserify src/browser.js --standalone Spark | uglifyjs --compress --mangle --comments false > lib/sparkexecute.min.js",
+    "test": "npx mocha --bail --exit --recursive --timeout 100000 --reporter nyan"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@coherentglobal/wasm-runner": "^0.0.45",
+    "@types/node": "^18.7.18",
+    "axios": "^0.27.2",
+    "chai": "^4.3.6",
+    "got": "^11.8.3",
+    "http-status-codes": "^2.2.0",
+    "joi": "^17.6.0",
+    "jstify": "^0.14.0",
+    "pino": "^8.5.0",
+    "prettier": "^2.7.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.18.10",
+    "@babel/core": "^7.19.0",
+    "@babel/plugin-transform-runtime": "^7.18.10",
+    "@babel/preset-env": "^7.19.0",
+    "babel-eslint": "^10.1.0",
+    "babelify": "^10.0.0",
+    "browserify": "^17.0.0",
+    "eslint": "^8.22.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-node": "^4.1.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^29.0.2",
+    "jsdoc": "^3.6.11",
+    "mocha": "^10.0.0",
+    "should": "^13.2.3",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.8.3",
+    "uglify-js": "^3.17.0"
+  },
+  "overrides": {
+    "@types/cacheable-request": "8.3.1"
+  },
+  "browserify": {
+    "transform": [
+      [
+        "babelify",
+        {
+          "presets": [
+            "@babel/preset-env"
+          ],
+          "plugins": [
+            [
+              "@babel/plugin-transform-runtime",
+              {
+                "regenerator": true
+              }
+            ]
+          ]
+        }
+      ]
+    ]
+  }
+}

package/src/browser.js

@@ -0,0 +1,198 @@
+const utils = require("./helpers/utils.js");
+const WasmRunnerErrors = require("./error.js");
+const { WasmRunner } = require("@coherentglobal/wasm-runner");
+const validate = require("./validate.js");
+const processModels = require("./models.js");
+
+let registry = [];
+let INVOCATION_CACHE = [];
+
+class Spark {
+  /**
+   * @param {object} config
+   */
+  constructor(config) {
+    /**
+     * @private
+     */
+    this.config = this.validateConfig(config);
+
+    const {
+      sparkEndpoint: { syntheticKey, bearerToken, authType, tenant, url },
+      nodeGenModels,
+    } = this.config;
+    /**
+     * @private
+     */
+    this.tenant = tenant;
+    /**
+     * @private
+     */
+    this.authType = authType;
+    /**
+     * @private
+     */
+    this.token = syntheticKey || bearerToken;
+    /**
+     * @private
+     */
+    this.url = url;
+    /**
+     * @private
+     */
+    this.isCompatible = utils.isWasmSupported();
+    /**
+     * @private
+     */
+    this.model = this._models(nodeGenModels);
+    /**
+     * @private
+     */
+    this.fallbackEnabled = false;
+  }
+  /**
+   *
+   * @param {object} nodegen
+   * @returns {object}
+   */
+  _models(nodegen) {
+    const models = nodegen.map(processModels);
+    return models;
+  }
+  /**
+   *
+   * @param {object} config
+   * @returns {object}
+   */
+  validateConfig(config) {
+    const { value, error } = validate(config);
+    if (!error) {
+      return value;
+    } else {
+      const message = JSON.stringify(error.details);
+      throw new Error(`ValidationError: ${message}`);
+    }
+  }
+  /**
+   *
+   * @param {string} id
+   * @returns {boolean}
+   */
+  _getModel(id) {
+    const model = this.model.find((m) => m.versionId === id);
+    if (!model) throw new WasmRunnerErrors.MissingModelError(id);
+
+    return model;
+  }
+  /**
+   *
+   * @param {string} versionId
+   */
+  async load(versionId) {
+    const { versionId: versionUuid, binary: modelPath } =
+      this._getModel(versionId);
+
+    console.log("SPARK load: ", modelPath);
+    if (!utils.isEmpty(registry)) {
+      registry = new WasmRunner();
+    }
+
+    await registry.append({
+      id: versionUuid,
+      url: modelPath,
+      // size,
+    });
+
+    INVOCATION_CACHE = [...INVOCATION_CACHE, { id: versionUuid }];
+  }
+
+  isExist = (model) => {
+    return registry.isExist(model);
+  };
+
+  /**
+   * Execute model
+   *
+   * @param {object} input
+   * @param {string} version_id
+   * @returns {object}
+   */
+  async execute(input, version_id) {
+    if (!input.request_meta.version_id && !input.request_meta.version_uuid) {
+      input.request_meta.version_id = version_id;
+    }
+    const versionID =
+      input.request_meta.version_id || input.request_meta.version_uuid;
+
+    const model = this._getModel(versionID);
+
+    await this.load(model.versionId);
+
+    // logger.info({
+    //   EventType: "ExecuteModel",
+    //   TextMessage: `Execute uuid: ${model.versionId}`,
+    // });
+
+    if (input && this.isExist(model.versionId)) {
+      let modelUrl = "";
+
+      if (
+        !this.isCompatible &&
+        !utils.isEmpty(this.url) &&
+        this.fallbackEnabled
+      ) {
+        let token = "";
+        if (this.token.constructor.name === "AsyncFunction") {
+          token = await this.token();
+        } else {
+          token = this.token;
+        }
+        console.log("TOKEN", token);
+
+        if (utils.isEmpty(this.token)) {
+          throw new WasmRunnerErrors.UnauthorizedError();
+        }
+        const header = utils.getAuthHeaders(token, this.authType, this.tenant);
+
+        const options = {
+          method: "POST",
+          body: JSON.stringify({
+            request_data: {},
+            request_meta: input.request_meta,
+          }),
+          headers: { ...{ "content-type": "application/json" }, ...header },
+        };
+
+        // console.log("OPTIONS", options);
+        modelUrl = new URL(
+          `/${this.tenant}/api/v3/version/${input.request_meta.version_id}`,
+          this.url
+        );
+        try {
+          console.log("URL", modelUrl);
+          const response = await fetch(modelUrl, options);
+
+          return await response.json();
+        } catch (err) {
+          throw new WasmRunnerErrors.UnauthorizedError();
+        }
+      } else if (this.isCompatible) {
+        const modelIndex = INVOCATION_CACHE.findIndex(
+          (item) => item.id === model.versionId
+        );
+
+        INVOCATION_CACHE.lastUsed = Date.now();
+
+        const result = await registry.execute(input, model.versionId, true);
+
+        return result;
+      } else {
+        throw new WasmRunnerErrors.NotSupportedError(
+          "WebAssembly is not supported"
+        );
+      }
+    }
+  }
+}
+
+module.exports = Spark;

package/src/error.js

@@ -0,0 +1,87 @@
+class WasmError extends Error {
+  constructor(message) {
+    super(message);
+    this.status = 500;
+  }
+
+  get v3() {
+    return {
+      error_category: this.name,
+      error_type: this.type,
+      message: this.message,
+      severity: this.severity,
+    };
+  }
+
+  get modelInfo() {
+    return {
+      uuid: this.uuid,
+      input: this.input,
+    };
+  }
+}
+
+class BrowserError extends WasmError {
+  constructor(message) {
+    super(message);
+    this.name = "browser_error";
+    this.type = "error.BROWSER_ERROR";
+    this.severity = "low";
+  }
+}
+
+class NotSupportedError extends BrowserError {
+  constructor(support, uuid = "", input = {}) {
+    super(`${support} support is required`);
+    this.name = "not_supported_error";
+    this.type = "error.NOT_SUPPORTED";
+    this.severity = "high";
+    this.uuid = uuid;
+    this.input = input;
+  }
+}
+
+class ModelError extends WasmError {
+  constructor(message) {
+    super(message);
+    this.name = "model_error";
+    this.type = "error.MODEL_ERROR";
+    this.severity = "low";
+  }
+}
+
+class MissingModelError extends ModelError {
+  constructor(uuid) {
+    super(`Model ${uuid} cannot be found.`);
+    this.name = "missing_model_error";
+    this.uuid = uuid;
+    this.type = "error.MISSING_MODEL_ERROR";
+    this.severity = "low";
+  }
+}
+
+class UnauthorizedError extends WasmError {
+  constructor(message, status) {
+    super(message || "Unauthorized");
+    this.status = status || 401;
+    this.name = "unauthorized";
+    this.type = "error.UNAUTHORIZED";
+  }
+}
+
+class BadRequestError extends WasmError {
+  constructor(message, status) {
+    super(message);
+    this.status = status || 400;
+    this.name = "bad_request_error";
+    this.type = "error.BAD_REQUEST_ERROR";
+  }
+}
+
+module.exports = {
+  MissingModelError,
+  BrowserError,
+  NotSupportedError,
+  UnauthorizedError,
+  BadRequestError,
+};

package/src/helpers/utils.js

@@ -0,0 +1,79 @@
+const WasmRunnerErrors = require("../error.js");
+
+const isEmpty = (obj) => {
+  [Object, Array].includes((obj || {}).constructor) &&
+    !Object.entries(obj || {}).length;
+};
+
+const isValidURL = (url) => {
+  try {
+    new URL(url);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+function isBrowser() {
+  try {
+    // eslint-disable-next-line no-undef
+    return window;
+  } catch (e) {
+    return false;
+  }
+}
+
+function isWasmSupported() {
+  try {
+    if (
+      typeof WebAssembly === "object" &&
+      typeof WebAssembly.instantiate === "function"
+    ) {
+      const module = new WebAssembly.Module(
+        Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00)
+      );
+
+      if (module instanceof WebAssembly.Module) {
+        return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;
+      }
+    }
+  } catch (e) {}
+  return false;
+}
+
+function isCompatible() {
+  // if (!isBrowser()) {
+  //   throw new WasmRunnerErrors.NotSupportedError(
+  //     "Javascript Browser Environment"
+  //   );
+  // }
+
+  if (!isWasmSupported()) {
+    throw new WasmRunnerErrors.NotSupportedError("WebAssembly");
+  }
+
+  return true;
+}
+
+const getAuthHeaders = (token, authType, tenant) => {
+  const authHeaders = {};
+  if (authType === "syntheticKey") {
+    authHeaders["x-tenant-name"] = tenant;
+    authHeaders["x-synthetic-key"] = token;
+  }
+
+  if (authType === "bearerToken") {
+    authHeaders.authorization = `Bearer ${token}`;
+  }
+
+  return authHeaders;
+};
+
+module.exports = {
+  isEmpty,
+  isValidURL,
+  isCompatible,
+  isWasmSupported,
+  isBrowser,
+  getAuthHeaders,
+};

package/src/logger.js

@@ -0,0 +1,3 @@
+const pino = require("pino");
+
+module.exports = pino({});

package/src/models.js

@@ -0,0 +1,26 @@
+/**
+ *
+ * @param {object} nodegen
+ * @returns
+ */
+const processModels = (nodegen) => {
+  switch (nodegen.type) {
+    case "binary":
+    case "uint8array":
+    case "base64":
+      console.log("ENTERED PROCESSING");
+      const model = Buffer.from(nodegen.binary, "base64");
+      nodegen.binary = model;
+      console.log("NODE: ", nodegen.binary);
+      break;
+    case "function":
+      const func = nodegen.binary;
+      nodegen.binary = func();
+    default:
+      break;
+  }
+
+  return nodegen;
+};
+
+module.exports = processModels;