Tweaks for unknown operator

Author: TotalTechGeek

asLogic.test.js

@@ -70,9 +70,14 @@ describe('asLogicAsync', () => {
 
   it('Should not allow you to create a builder with methods that do not exist', async () => {
     const builder = asLogicAsync(module)
-    expect(builder({
-      hello: { '+': [1, 2] }
-    })).rejects.toThrow()
+    try {
+      await builder({
+        hello: { '+': [1, 2] }
+      })
+    } catch (e) {
+      return
+    }
+    throw new Error('Should have thrown an error')
   })
 
   it('Should let you select logic kept', async () => {

asyncLogic.js

@@ -74,7 +74,9 @@ class AsyncLogicEngine {
     const data = logic[func]
 
     if (this.isData(logic, func)) return logic
-    if (!this.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+
+    // eslint-disable-next-line no-throw-literal
+    if (!this.methods[func]) throw { type: 'Unknown Operator', key: func }
 
     // A small but useful micro-optimization for some of the most common functions.
     // Later on, I could define something to shut this off if var / val are redefined.

async_optimizer.js

@@ -85,6 +85,8 @@ export function optimize (logic, engine, above = []) {
     const keys = Object.keys(logic)
     const methodName = keys[0]
 
+    if (keys.length === 0) return logic
+
     const isData = engine.isData(logic, methodName)
     if (isData) return () => logic
 
@@ -113,6 +115,9 @@ export function optimize (logic, engine, above = []) {
       }
       return result
     }
+
+    // eslint-disable-next-line no-throw-literal
+    throw { type: 'Unknown Operator', key: methodName }
   }
 
   return logic

compiler.js

@@ -86,7 +86,9 @@ export function isDeterministic (method, engine, buildState) {
 
     if (engine.isData(method, func)) return true
     if (lower === undefined) return true
-    if (!engine.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+
+    // eslint-disable-next-line no-throw-literal
+    if (!engine.methods[func]) throw { type: 'Unknown Operator', key: func }
 
     if (engine.methods[func].lazy) {
       return typeof engine.methods[func].deterministic === 'function'
@@ -176,7 +178,8 @@ function buildString (method, buildState = {}) {
     if (!engine.methods[func]) {
       // Check if this is supposed to be "data" rather than a function.
       if (engine.isData(method, func)) return pushValue(method, true)
-      throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+      // eslint-disable-next-line no-throw-literal
+      throw { type: 'Unknown Operator', key: func }
     }
 
     if (

defaultMethods.js

@@ -20,7 +20,8 @@ function isDeterministic (method, engine, buildState) {
     const lower = method[func]
 
     if (engine.isData(method, func) || func === undefined) return true
-    if (!engine.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    // eslint-disable-next-line no-throw-literal
+    if (!engine.methods[func]) throw { type: 'Unknown Operator', key: func }
 
     if (engine.methods[func].lazy) {
       return typeof engine.methods[func].deterministic === 'function'
@@ -45,7 +46,8 @@ function isSyncDeep (method, engine, buildState) {
     const func = Object.keys(method)[0]
     const lower = method[func]
     if (engine.isData(method, func) || func === undefined) return true
-    if (!engine.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    // eslint-disable-next-line no-throw-literal
+    if (!engine.methods[func]) throw { type: 'Unknown Operator', key: func }
     if (engine.methods[func].lazy) return typeof engine.methods[func][Sync] === 'function' ? engine.methods[func][Sync](lower, buildState) : engine.methods[func][Sync]
     return typeof engine.methods[func][Sync] === 'function' ? engine.methods[func][Sync](lower, buildState) : engine.methods[func][Sync] && isSyncDeep(lower, engine, buildState)
   }

logic.js

@@ -65,7 +65,8 @@ class LogicEngine {
 
     if (this.isData(logic, func)) return logic
 
-    if (!this.methods[func]) throw new Error(`Method '${func}' was not found in the Logic Engine.`)
+    // eslint-disable-next-line no-throw-literal
+    if (!this.methods[func]) throw { type: 'Unknown Operator', key: func }
 
     // A small but useful micro-optimization for some of the most common functions.
     // Later on, I could define something to shut this off if var / val are redefined.

optimizer.js

@@ -195,6 +195,8 @@ export function optimize (logic, engine, above = []) {
     const keys = Object.keys(logic)
     const methodName = keys[0]
 
+    if (keys.length === 0) return logic
+
     const isData = engine.isData(logic, methodName)
     if (isData) return () => logic
 
@@ -207,6 +209,9 @@ export function optimize (logic, engine, above = []) {
       if (deterministic) return result()
       return result
     }
+
+    // eslint-disable-next-line no-throw-literal
+    throw { type: 'Unknown Operator', key: methodName }
   }
 
   return logic

suites/bad.json

@@ -0,0 +1,14 @@
+[
+    { 
+      "description": "Single key object, does not map to operator",
+      "rule": { "UnknownOperator": true },
+      "data": null,
+      "error": { "type": "Unknown Operator", "key": "UnknownOperator" } 
+    },
+    {
+      "description": "Multi-Key Object",
+      "rule": { "UnknownOperator": true, "UnknownOperator2": true },
+      "data": null,
+      "error": {} 
+    }
+  ]