feat: keys, values, sort functions

Author: dreamorosi

packages/jmespath/src/Parser.ts

@@ -40,7 +40,7 @@ import type { Node, Token } from './types';
  * If you don't want to read the full paper, there are some other good
  * overviews that explain the general idea:
  * - [Pratt Parsers: Expression Parsing Made Easy](https://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/)
- * - [Simple Top-Down Parsing in Python](http://effbot.org/zone/simple-top-down-parsing.htm)
+ * - [Simple Top-Down Parsing in Python](https://11l-lang.org/archive/simple-top-down-parsing/)
  * - [Top Down Operator Precedence](http://javascript.crockford.com/tdop/tdop.html)
  */
 class Parser {

packages/jmespath/src/functions/Functions.ts

@@ -1,4 +1,4 @@
-import { Expression, isNumber, isRecord } from '../visitor/utils';
+import { Expression, getType, isNumber, isRecord } from '../visitor/utils';
 import type { JSONArray, JSONObject, JSONValue } from '../types';
 import { typeCheck, arityCheck } from './typeChecking';
 
@@ -234,6 +234,19 @@ class Functions {
       : arg.split('').reverse().join('');
   }
 
+  /**
+   * Sort the provided array.
+   *
+   * @param arg The array to sort
+   * @returns The sorted array
+   */
+  @Functions.signature({
+    argumentsSpecs: [['array-number', 'array-string']],
+  })
+  public funcSort(arg: Array<unknown>): Array<unknown> {
+    return arg.sort();
+  }
+
   /**
    * Determines if the provided string starts with the provided suffix.
    *
@@ -330,21 +343,7 @@ class Functions {
     argumentsSpecs: [['any']],
   })
   public funcType(arg: JSONValue): string {
-    if (Array.isArray(arg)) {
-      return 'array';
-    } else if (isRecord(arg)) {
-      return 'object';
-    } else if (typeof arg === 'string') {
-      return 'string';
-    } else if (typeof arg === 'number') {
-      return 'number';
-    } else if (typeof arg === 'boolean') {
-      return 'boolean';
-    } else if (Object.is(arg, null)) {
-      return 'null';
-    } else {
-      return 'unknown';
-    }
+    return getType(arg);
   }
 
   /**

packages/jmespath/src/functions/typeChecking.ts

@@ -1,4 +1,4 @@
-import { isRecord } from '../visitor/utils';
+import { getType, isRecord } from '../visitor/utils';
 import { JMESPathTypeError, ArityError, VariadicArityError } from '../errors';
 
 /**
@@ -78,7 +78,7 @@ const typeCheckArgument = (arg: unknown, argumentSpec: Array<string>): void => {
         throw new JMESPathTypeError({
           currentValue: arg,
           expectedTypes: argumentSpec,
-          actualType: Object.is(arg, null) ? 'null' : typeof arg,
+          actualType: getType(arg),
         });
       }
       if (type.includes('-')) {
@@ -103,7 +103,7 @@ const typeCheckArgument = (arg: unknown, argumentSpec: Array<string>): void => {
             throw new JMESPathTypeError({
               currentValue: arg,
               expectedTypes: argumentSpec,
-              actualType: type === 'boolean' ? 'boolean' : typeof arg, // TODO: fix this
+              actualType: getType(arg),
             });
           }
           continue;
@@ -115,7 +115,7 @@ const typeCheckArgument = (arg: unknown, argumentSpec: Array<string>): void => {
             throw new JMESPathTypeError({
               currentValue: arg,
               expectedTypes: argumentSpec,
-              actualType: typeof arg,
+              actualType: getType(arg),
             });
           }
           continue;
@@ -127,7 +127,7 @@ const typeCheckArgument = (arg: unknown, argumentSpec: Array<string>): void => {
             throw new JMESPathTypeError({
               currentValue: arg,
               expectedTypes: argumentSpec,
-              actualType: typeof arg,
+              actualType: getType(arg),
             });
           }
           continue;

packages/jmespath/src/visitor/utils.ts

@@ -205,6 +205,24 @@ const sliceArray = <T>(
   return result;
 };
 
+const getType = (value: unknown): string => {
+  if (Array.isArray(value)) {
+    return 'array';
+  } else if (isRecord(value)) {
+    return 'object';
+  } else if (typeof value === 'string') {
+    return 'string';
+  } else if (isNumber(value)) {
+    return 'number';
+  } else if (typeof value === 'boolean') {
+    return 'boolean';
+  } else if (Object.is(value, null)) {
+    return 'null';
+  } else {
+    return 'unknown';
+  }
+};
+
 export {
   Expression,
   isRecord,
@@ -213,4 +231,5 @@ export {
   isNumber,
   isIntegerNumber,
   sliceArray,
+  getType,
 };

packages/jmespath/tests/unit/functions.test.ts

@@ -935,12 +935,11 @@ describe('Functions tests', () => {
     expect(result).toStrictEqual(expected);
   });
 
-  /* it.each([
+  it.each([
     {
       expression: 'sort(keys(objects))',
       expected: ['bar', 'foo'],
     },
-
     {
       expression: 'sort(values(objects))',
       expected: ['bar', 'baz'],
@@ -961,6 +960,10 @@ describe('Functions tests', () => {
       expression: 'sort(decimals)',
       expected: [-1.5, 1.01, 1.2],
     },
+    {
+      expression: 'sort(empty_list)',
+      expected: [],
+    },
   ])(
     'should support the sort(), key(), and values() functions',
     ({ expression, expected }) => {
@@ -989,61 +992,70 @@ describe('Functions tests', () => {
       // Assess
       expect(result).toStrictEqual(expected);
     }
-  ); */
+  );
 
-  /* it.each([
+  it.each([
     {
       expression: 'keys(foo)',
       error:
-        'TypeError: keys() expected argument 1 to be type (object) but received type number instead.',
+        'Invalid argument type for function keys(), expected "object" but found "number" in expression: keys(foo)',
     },
     {
       expression: 'keys(strings)',
       error:
-        'TypeError: keys() expected argument 1 to be type (object) but received type array instead.',
+        'Invalid argument type for function keys(), expected "object" but found "array" in expression: keys(strings)',
     },
     {
       expression: 'keys(`false`)',
       error:
-        'TypeError: keys() expected argument 1 to be type (object) but received type boolean instead.',
+        'Invalid argument type for function keys(), expected "object" but found "boolean" in expression: keys(`false`)',
     },
     {
       expression: 'values(foo)',
       error:
-        'TypeError: values() expected argument 1 to be type (object) but received type number instead.',
+        'Invalid argument type for function values(), expected "object" but found "number" in expression: values(foo)',
     },
     {
       expression: 'sort(array)',
       error:
-        'TypeError: sort() expected argument 1 to be type (Array<string> | Array<number>) but received type array instead.',
+        'Invalid argument type for function sort(), expected "number" but found "string" in expression: sort(array)',
     },
     {
       expression: 'sort(abc)',
       error:
-        'TypeError: sort() expected argument 1 to be type (Array<string> | Array<number>) but received type null instead.',
-    },
-    {
-      expression: 'sort(empty_list)',
-      expected: [],
+        'Invalid argument type for function sort(), expected one of "array-number", "array-string" but found "null" in expression: sort(abc)',
     },
     {
       expression: 'sort(@)',
       error:
-        'TypeError: sort() expected argument 1 to be type (Array<string> | Array<number>) but received type object instead.',
+        'Invalid argument type for function sort(), expected one of "array-number", "array-string" but found "object" in expression: sort(@)',
     },
   ])(
     'sort(), keys(), and values() function errors',
     ({ expression, error }) => {
-      // TODO: see if we can assert the error type as well in sort(), keys(), values() errors tests
       // Prepare
       const data = {
-        type: 'object',
+        foo: -1,
+        zero: 0,
+        numbers: [-1, 3, 4, 5],
+        array: [-1, 3, 4, 5, 'a', '100'],
+        strings: ['a', 'b', 'c'],
+        decimals: [1.01, 1.2, -1.5],
+        str: 'Str',
+        false: false,
+        empty_list: [],
+        empty_hash: {},
+        objects: {
+          foo: 'bar',
+          bar: 'baz',
+        },
+        null_key: null,
       };
 
       // Act & Assess
       expect(() => search(expression, data)).toThrow(error);
     }
-  ); */
+  );
 
   /* it.each([
     {
@@ -1228,7 +1240,7 @@ describe('Functions tests', () => {
     {
       expression: 'starts_with(str, `0`)',
       error:
-        'Invalid argument type for function starts_with(), expected "string" but found "object" in expression: starts_with(str, `0`)',
+        'Invalid argument type for function starts_with(), expected "string" but found "null" in expression: starts_with(str, `0`)',
     },
   ])('starts_with() function errors', ({ expression, error }) => {
     // Prepare