@coherentglobal/spark-execute-sdk 0.3.11 → 0.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coherentglobal/spark-execute-sdk",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "",
   "main": "src/node.js",
   "browser": "dist/browser.js",

package/src/browser.js

@@ -47,7 +47,7 @@ class Spark {
     /**
      * @private
      */
-    this.fallbackEnabled = false;
+    this.priority = ["model", "onlineEndpoint"];
   }
   /**
    *
@@ -85,9 +85,138 @@ class Spark {
     return model;
   }
 
+  _findModel(requestMeta) {
+    let model = {};
+    if (requestMeta.version_id) {
+      model = this.model.filter(({ versionId }) => {
+        return versionId === requestMeta.version_id;
+      });
+    } else if (requestMeta.servicename && requestMeta.version) {
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ServiceName === requestMeta.servicename &&
+          metaData.EngineInformation.Revision === requestMeta.version
+      );
+    } else if (requestMeta.servicename && requestMeta.transaction_date) {
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ServiceName === requestMeta.servicename &&
+          new Date(requestMeta.transaction_date) >=
+            new Date(metaData.effectiveStartDate) &&
+          new Date(requestMeta.transaction_date) <=
+            new Date(metaData.effectiveEndDate)
+      );
+
+      if (model.length > 1) {
+        return model
+          .sort((versionA, versionB) =>
+            versionA.metaData.EngineInformation.Revision.replace(
+              /\d+/g,
+              (n) => +n + 100000
+            ).localCompare(
+              versionB.metaData.EngineInformation.Revision.replace(
+                /\d+/g,
+                (n) => +n + 100000
+              )
+            )
+          )
+          .reverse();
+      }
+    } else if (requestMeta.service_id && requestMeta.version) {
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ServiceGuid === requestMeta.service_id &&
+          metaData.EngineInformation.Revision === requestMeta.version
+      );
+    } else if (requestMeta.service_id && requestMeta.transaction_date) {
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ServiceGuid === requestMeta.service_id &&
+          new Date(requestMeta.transaction_date) >=
+            new Date(metaData.effectiveStartDate) &&
+          new Date(requestMeta.transaction_date) <=
+            new Date(metaData.effectiveEndDate)
+      );
+
+      if (model.length > 1) {
+        return model
+          .sort((versionA, versionB) =>
+            versionA.metaData.EngineInformation.Revision.replace(
+              /\d+/g,
+              (n) => +n + 100000
+            ).localCompare(
+              versionB.metaData.EngineInformation.Revision.replace(
+                /\d+/g,
+                (n) => +n + 100000
+              )
+            )
+          )
+          .reverse();
+      }
+    } else if (requestMeta.service_uri && requestMeta.transaction_date) {
+      const regex = /folders\/(.+)\/services\/(.+)/gi;
+      const parts = regex.exec(requestMeta.service_uri);
+      let folder, service;
+      if (parts) {
+        folder = decodeURI(parts[1]);
+        service = decodeURI(parts[2]);
+      }
+
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ProductName === folder &&
+          metaData.EngineInformation.ServiceName === service &&
+          new Date(requestMeta.transaction_date) >=
+            new Date(metaData.effectiveStartDate) &&
+          new Date(requestMeta.transaction_date) <=
+            new Date(metaData.effectiveEndDate)
+      );
+
+      if (model.length > 1) {
+        return model
+          .sort((versionA, versionB) =>
+            versionA.metaData.EngineInformation.Revision.replace(
+              /\d+/g,
+              (n) => +n + 100000
+            ).localCompare(
+              versionB.metaData.EngineInformation.Revision.replace(
+                /\d+/g,
+                (n) => +n + 100000
+              )
+            )
+          )
+          .reverse();
+      }
+    } else if (requestMeta.service_uri && requestMeta.version) {
+      const regex = /folders\/(.+)\/services\/(.+)/gi;
+      const parts = regex.exec(requestMeta.service_uri);
+      let folder, service;
+      if (parts) {
+        folder = decodeURI(parts[1]);
+        service = decodeURI(parts[2]);
+      }
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ProductName === folder &&
+          metaData.EngineInformation.ServiceName === service &&
+          metaData.EngineInformation.Revision === requestMeta.version
+      );
+    } else {
+      throw new Error(
+        "Model not found. requestMeta: " +
+          JSON.stringify(requestMeta) +
+          " tenant: " +
+          this.tenant
+      );
+    }
+
+    return model[0];
+  }
+
   _getModelByMeta(folderName, serviceName) {
     const model = this.model.find(
-      m => m?.metaData?.EngineInformation?.ProductName === folderName &&
+      (m) =>
+        m?.metaData?.EngineInformation?.ProductName === folderName &&
         m?.metaData?.EngineInformation?.ServiceName === serviceName
     );
     if (!model) throw new WasmRunnerErrors.MissingModelError(serviceName);
@@ -99,7 +228,7 @@ class Spark {
    * Execute model
    *
    * @param {object} input
-   * @param {string} version_id
+   * @param {string} [version_id] version_id
    * @returns {object}
    */
   async execute(input, version_id) {
@@ -108,108 +237,114 @@ class Spark {
       input.request_meta.version_id ||
       input.request_meta.version_uuid;
 
-    const model = this._getModel(versionID);
-
-    if (input) {
-      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;
-        }
-
-        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 },
-        };
+    let lookup = {
+      model: this.offlineModel,
+      onlineEndpoint: this.onlineModelEndpoint,
+    };
+
+    let response;
+
+    response = await lookup[this.priority[0]](input, versionID, this);
+    if (response instanceof Error) {
+      response = await lookup[this.priority[1]](input, versionID, this);
+    }
+
+    return response;
+  }
 
-        modelUrl = new URL(
-          `/${this.tenant}/api/v3/version/${input.request_meta.version_id}`,
-          this.url
-        );
-        try {
-          const response = await fetch(modelUrl, options);
-
-          return await response.json();
-        } catch (err) {
-          throw new WasmRunnerErrors.UnauthorizedError();
-        }
-      } else if (this.isCompatible) {
-        if (!(registry instanceof WasmRunner)) {
-
-          /**
-           * Options is the request data the the runner dispatch
-           * receives from the wasm model
-           * @param {*} options 
-           * @returns 
-           */
-          const callback = async (options) => {
-            const hasFolderName = options?.folder_name
-            const hasServiceName = options?.service_name
-            let hasVersionId = options?.version_id
-            if (hasVersionId && !registry.isExist(hasVersionId)) {
-              await registry.append({
-                id: hasVersionId,
-                url: model.binary,
-                meta: {
-                  folder_name: model?.metaData?.EngineInformation?.ProductName ?? "",
-                  service_name: model?.metaData?.EngineInformation?.ServiceName ?? ""
-                }
-              });
-            } else {
-              const model = this._getModelByMeta(hasFolderName, hasServiceName)
-              hasVersionId = model?.versionId
-              await registry.append({
-                id: hasVersionId,
-                url: model.binary,
-                meta: {
-                  folder_name: model?.metaData?.EngineInformation?.ProductName ?? "",
-                  service_name: model?.metaData?.EngineInformation?.ServiceName ?? ""
-                }
-              });
-            }
-            return hasVersionId
+  async offlineModel(input, versionID, ds) {
+    console.log("OFFLINES");
+    try {
+      if (!(registry instanceof WasmRunner)) {
+        /**
+         * Options is the request data the the runner dispatch
+         * receives from the wasm model
+         * @param {*} options
+         * @returns
+         */
+        const callback = async (options) => {
+          const hasFolderName = options?.folder_name;
+          const hasServiceName = options?.service_name;
+          let hasVersionId = options?.version_id;
+          if (hasVersionId && !registry.isExist(hasVersionId)) {
+            await registry.append({
+              id: hasVersionId,
+              url: model.binary,
+              meta: {
+                folder_name:
+                  model?.metaData?.EngineInformation?.ProductName ?? "",
+                service_name:
+                  model?.metaData?.EngineInformation?.ServiceName ?? "",
+              },
+            });
+          } else {
+            const model = ds._getModelByMeta(hasFolderName, hasServiceName);
+            hasVersionId = model?.versionId;
+            await registry.append({
+              id: hasVersionId,
+              url: model.binary,
+              meta: {
+                folder_name:
+                  model?.metaData?.EngineInformation?.ProductName ?? "",
+                service_name:
+                  model?.metaData?.EngineInformation?.ServiceName ?? "",
+              },
+            });
           }
-          registry = new WasmRunner("", callback);
-        }
-
-        if (!registry.isExist(versionID)) {
-          const model = this._getModel(versionID);
-          await registry.append({
-            id: versionID,
-            url: model.binary,
-            meta: {
-              folder_name: model?.folder_name ?? "",
-              service_name: model?.service_name ?? ""
-            }
-          });
-        }
-        const result = await registry.execute(input, versionID, () => {
+          return hasVersionId;
+        };
+        registry = new WasmRunner("", callback);
+      }
 
+      if (!registry.isExist(versionID)) {
+        const model = ds._findModel(versionID);
+        await registry.append({
+          id: versionID,
+          url: model.binary,
+          meta: {
+            folder_name: model?.folder_name ?? "",
+            service_name: model?.service_name ?? "",
+          },
         });
-
-        return result;
-      } else {
-        throw new WasmRunnerErrors.NotSupportedError(
-          "WebAssembly is not supported"
-        );
       }
+      const result = await registry.execute(input, versionID, () => {});
+      return result;
+    } catch (err) {
+      return err;
+    }
+  }
+
+  async onlineModelEndpoint(input, versionID, ds) {
+    let token = "";
+    if (ds.token.constructor.name === "AsyncFunction") {
+      token = await ds.token();
+    } else {
+      token = ds.token;
+    }
+
+    if (utils.isEmpty(ds.token)) {
+      throw new WasmRunnerErrors.UnauthorizedError();
+    }
+    try {
+      const header = utils.getAuthHeaders(token, ds.authType, ds.tenant);
+
+      const options = {
+        method: "POST",
+        body: JSON.stringify({
+          request_data: {},
+          request_meta: input.request_meta,
+        }),
+        headers: { ...{ "content-type": "application/json" }, ...header },
+      };
+
+      const modelUrl = new URL(`/${ds.tenant}/api/v3/execute`, ds.url);
+
+      const response = await fetch(modelUrl, options);
+
+      const result = await response.json();
+      return result;
+    } catch (err) {
+      return err;
     }
   }
 }

package/src/node.js

@@ -5,6 +5,7 @@ const logger = require("./logger");
 const validate = require("./validate.js");
 const processModels = require("./models.js");
 const got = require("got");
+const { object } = require("joi");
 
 let registry = [];
 
@@ -46,11 +47,10 @@ class Spark {
      * @private
      */
     this.model = this._models(nodeGenModels);
-
     /**
      * @private
      */
-    this.fallbackEnabled = false;
+    this.priority = ["model", "onlineEndpoint"];
   }
 
   /**
@@ -94,11 +94,139 @@ class Spark {
     return model;
   }
 
+  _findModel(requestMeta) {
+    let model = {};
+    if (requestMeta.version_id) {
+      model = this.model.filter(({ versionId }) => {
+        return versionId === requestMeta.version_id;
+      });
+    } else if (requestMeta.servicename && requestMeta.version) {
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ServiceName === requestMeta.servicename &&
+          metaData.EngineInformation.Revision === requestMeta.version
+      );
+    } else if (requestMeta.servicename && requestMeta.transaction_date) {
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ServiceName === requestMeta.servicename &&
+          new Date(requestMeta.transaction_date) >=
+            new Date(metaData.effectiveStartDate) &&
+          new Date(requestMeta.transaction_date) <=
+            new Date(metaData.effectiveEndDate)
+      );
+
+      if (model.length > 1) {
+        return model
+          .sort((versionA, versionB) =>
+            versionA.metaData.EngineInformation.Revision.replace(
+              /\d+/g,
+              (n) => +n + 100000
+            ).localCompare(
+              versionB.metaData.EngineInformation.Revision.replace(
+                /\d+/g,
+                (n) => +n + 100000
+              )
+            )
+          )
+          .reverse();
+      }
+    } else if (requestMeta.service_id && requestMeta.version) {
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ServiceGuid === requestMeta.service_id &&
+          metaData.EngineInformation.Revision === requestMeta.version
+      );
+    } else if (requestMeta.service_id && requestMeta.transaction_date) {
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ServiceGuid === requestMeta.service_id &&
+          new Date(requestMeta.transaction_date) >=
+            new Date(metaData.effectiveStartDate) &&
+          new Date(requestMeta.transaction_date) <=
+            new Date(metaData.effectiveEndDate)
+      );
+
+      if (model.length > 1) {
+        return model
+          .sort((versionA, versionB) =>
+            versionA.metaData.EngineInformation.Revision.replace(
+              /\d+/g,
+              (n) => +n + 100000
+            ).localCompare(
+              versionB.metaData.EngineInformation.Revision.replace(
+                /\d+/g,
+                (n) => +n + 100000
+              )
+            )
+          )
+          .reverse();
+      }
+    } else if (requestMeta.service_uri && requestMeta.transaction_date) {
+      const regex = /folders\/(.+)\/services\/(.+)/gi;
+      const parts = regex.exec(requestMeta.service_uri);
+      let folder, service;
+      if (parts) {
+        folder = decodeURI(parts[1]);
+        service = decodeURI(parts[2]);
+      }
+
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ProductName === folder &&
+          metaData.EngineInformation.ServiceName === service &&
+          new Date(requestMeta.transaction_date) >=
+            new Date(metaData.effectiveStartDate) &&
+          new Date(requestMeta.transaction_date) <=
+            new Date(metaData.effectiveEndDate)
+      );
+
+      if (model.length > 1) {
+        return model
+          .sort((versionA, versionB) =>
+            versionA.metaData.EngineInformation.Revision.replace(
+              /\d+/g,
+              (n) => +n + 100000
+            ).localCompare(
+              versionB.metaData.EngineInformation.Revision.replace(
+                /\d+/g,
+                (n) => +n + 100000
+              )
+            )
+          )
+          .reverse();
+      }
+    } else if (requestMeta.service_uri && requestMeta.version) {
+      const regex = /folders\/(.+)\/services\/(.+)/gi;
+      const parts = regex.exec(requestMeta.service_uri);
+      let folder, service;
+      if (parts) {
+        folder = decodeURI(parts[1]);
+        service = decodeURI(parts[2]);
+      }
+      model = this.model.filter(
+        ({ metaData }) =>
+          metaData.EngineInformation.ProductName === folder &&
+          metaData.EngineInformation.ServiceName === service &&
+          metaData.EngineInformation.Revision === requestMeta.version
+      );
+    } else {
+      throw new Error(
+        "Model not found. requestMeta: " +
+          JSON.stringify(requestMeta) +
+          " tenant: " +
+          this.tenant
+      );
+    }
+
+    return model[0];
+  }
+
   /**
    * Execute model
    *
    * @param {object} input
-   * @param {string} version_id
+   * @param {string} [version_id] version_id
    * @returns {object}
    */
   async execute(input, version_id) {
@@ -107,85 +235,88 @@ class Spark {
       input.request_meta.version_id ||
       input.request_meta.version_uuid;
 
-    const model = this._getModel(versionID);
+    let lookup = {
+      model: this.offlineModel,
+      onlineEndpoint: this.onlineModelEndpoint,
+    };
 
-    // await this.load(model.versionId);
+    let response;
 
-    logger.info({
-      EventType: "ExecuteModel",
-      TextMessage: `Execute uuid: ${model.versionId}`,
-    });
-
-    if (input) {
-      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 options = {
-          headers: utils.getAuthHeaders(token, this.authType, this.tenant),
-          json: {
-            request_data: {},
-            request_meta: input.request_meta,
-          },
-        };
-
-        console.log("OPTIONS", options);
-        modelUrl = new URL(
-          `/${this.tenant}/api/v3/version/${input.request_meta.version_id}`,
-          this.url
-        );
-
-        try {
-          const response = await got.post(modelUrl, options).json();
-
-          return response;
-        } catch (err) {
-          throw new WasmRunnerErrors.UnauthorizedError();
-        }
-      } else if (this.isCompatible) {
-        if (!(registry instanceof WasmRunner)) {
-          registry = new WasmRunner();
-        }
-
-        if (!registry.isExist(versionID)) {
-          await registry.append({
-            id: versionID,
-            url: model.binary,
-            // size,
-          });
-        }
-        const result = await registry.execute(input, versionID);
-
-        return result;
-      } else {
-        throw new WasmRunnerErrors.NotSupportedError(
-          "WebAssembly is not supported"
-        );
-      }
-    } else {
-      throw new WasmRunnerErrors.BadRequestError("Missing request input.");
+    response = await lookup[this.priority[0]](input, versionID, this);
+    if (response instanceof Error) {
+      response = await lookup[this.priority[1]](input, versionID, this);
     }
+
+    return response;
   }
 
   /**
    * Remove Model
    */
   // async remove(versionId) {}
+
+  async offlineModel(input, versionID, ds) {
+    try {
+      const model = ds._findModel(input.request_meta);
+
+      logger.info({
+        EventType: "ExecuteModel",
+        TextMessage: `Execute uuid: ${model && model?.versionId}`,
+      });
+      if (!(registry instanceof WasmRunner)) {
+        registry = new WasmRunner();
+      }
+
+      if (!registry.isExist(versionID)) {
+        await registry.append({
+          id: versionID,
+          url: model?.binary || "",
+          // size,
+        });
+      }
+
+      let result = await registry.execute(input, versionID);
+
+      return result;
+    } catch (err) {
+      return err;
+    }
+  }
+
+  async onlineModelEndpoint(input, versionID, ds) {
+    logger.info({
+      EventType: "ExecuteOnlineModel",
+      TextMessage: `Execute uuid: ${versionID}`,
+    });
+
+    let token = "";
+    if (ds.token.constructor.name === "AsyncFunction") {
+      token = await ds.token();
+    } else {
+      token = ds.token;
+    }
+
+    if (utils.isEmpty(ds.token)) {
+      throw new WasmRunnerErrors.UnauthorizedError();
+    }
+    try {
+      const options = {
+        headers: utils.getAuthHeaders(token, ds.authType, ds.tenant),
+        json: {
+          request_data: {},
+          request_meta: input.request_meta,
+        },
+      };
+
+      let modelUrl = new URL(`/${ds.tenant}/api/v3/execute`, ds.url);
+
+      const result = await got.post(modelUrl, options).json();
+
+      return result;
+    } catch (err) {
+      return err;
+    }
+  }
 }
 
 module.exports = Spark;