Establishes that multi-key objects should fail

Author: TotalTechGeek

asyncLogic.js

@@ -69,14 +69,13 @@ class AsyncLogicEngine {
    * @param {*} above The context above (can be used for handlebars-style data traversal.)
    * @returns {Promise<*>}
    */
-  async _parse (logic, context, above) {
-    const [func] = Object.keys(logic)
+  async _parse (logic, context, above, func, length) {
     const data = logic[func]
 
     if (this.isData(logic, func)) return logic
 
     // eslint-disable-next-line no-throw-literal
-    if (!this.methods[func]) throw { type: 'Unknown Operator', key: func }
+    if (!this.methods[func] || length > 1) 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.
@@ -184,7 +183,13 @@ class AsyncLogicEngine {
       return res
     }
 
-    if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) return this._parse(logic, data, above)
+    if (logic && typeof logic === 'object' && Object.keys(logic).length > 0) {
+      const keys = Object.keys(logic)
+      if (keys.length > 0) {
+        const func = keys[0]
+        return this._parse(logic, data, above, func, keys.length)
+      }
+    }
 
     return logic
   }

async_optimizer.js

@@ -90,6 +90,9 @@ export function optimize (logic, engine, above = []) {
     const isData = engine.isData(logic, methodName)
     if (isData) return () => logic
 
+    // eslint-disable-next-line no-throw-literal
+    if (keys.length > 1) throw { type: 'Unknown Operator' }
+
     // If we have a deterministic function, we can just return the result of the evaluation,
     // basically inlining the operation.
     const deterministic = !engine.disableInline && isDeterministic(logic, engine, { engine })

compiler.js

@@ -171,11 +171,12 @@ function buildString (method, buildState = {}) {
     return result
   }
 
-  const func = method && Object.keys(method)[0]
-
   if (method && typeof method === 'object') {
+    const keys = Object.keys(method)
+    const func = keys[0]
+
     if (!func) return pushValue(method)
-    if (!engine.methods[func]) {
+    if (!engine.methods[func] || keys.length > 1) {
       // Check if this is supposed to be "data" rather than a function.
       if (engine.isData(method, func)) return pushValue(method, true)
       // eslint-disable-next-line no-throw-literal

logic.js

@@ -60,13 +60,13 @@ class LogicEngine {
    * @param {*} above The context above (can be used for handlebars-style data traversal.)
    * @returns {{ result: *, func: string }}
    */
-  _parse (logic, context, above, func) {
+  _parse (logic, context, above, func, length) {
     const data = logic[func]
 
     if (this.isData(logic, func)) return logic
 
     // eslint-disable-next-line no-throw-literal
-    if (!this.methods[func]) throw { type: 'Unknown Operator', key: func }
+    if (!this.methods[func] || length > 1) 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.
@@ -162,7 +162,7 @@ class LogicEngine {
       const keys = Object.keys(logic)
       if (keys.length > 0) {
         const func = keys[0]
-        return this._parse(logic, data, above, func)
+        return this._parse(logic, data, above, func, keys.length)
       }
     }
 

optimizer.js

@@ -200,6 +200,9 @@ export function optimize (logic, engine, above = []) {
     const isData = engine.isData(logic, methodName)
     if (isData) return () => logic
 
+    // eslint-disable-next-line no-throw-literal
+    if (keys.length > 1) throw { type: 'Unknown Operator' }
+
     // If we have a deterministic function, we can just return the result of the evaluation,
     // basically inlining the operation.
     const deterministic = !engine.disableInline && isDeterministic(logic, engine, { engine })

suites/bad.json

@@ -3,12 +3,18 @@
       "description": "Single key object, does not map to operator",
       "rule": { "UnknownOperator": true },
       "data": null,
-      "error": { "type": "Unknown Operator", "key": "UnknownOperator" } 
+      "error": { "type": "Unknown Operator"  } 
     },
     {
       "description": "Multi-Key Object",
       "rule": { "UnknownOperator": true, "UnknownOperator2": true },
       "data": null,
-      "error": {} 
+      "error": { "type": "Unknown Operator" } 
+    },
+    {
+      "description": "Multi-Key Object 2",
+      "rule": { "+": true, "UnknownOperator2": true },
+      "data": null,
+      "error": { "type": "Unknown Operator" } 
     }
   ]