Merge pull request #645 from streamich/object-expressions

Object JSON Expression operators

Author: streamich

src/json-expression/__tests__/codegen.spec.ts

@@ -18,8 +18,6 @@ const check = (
     operators: operatorsMap,
   });
   const fn = codegen.run().compile();
-  // console.log(codegen.generate().js);
-  // console.log(fn.toString());
   const result = fn({vars: new Vars(data)});
   expect(result).toStrictEqual(expected);
 };

src/json-expression/__tests__/jsonExpressionUnitTests.ts

@@ -1979,6 +1979,88 @@ export const jsonExpressionUnitTests = (
         );
       });
     });
+
+    describe('o.set', () => {
+      test('can set an object property', () => {
+        check(['o.set', {}, 'foo', 'bar'], {foo: 'bar'});
+      });
+
+      test('can set two properties, one computed', () => {
+        const expression: Expr = ['o.set', {}, 'foo', 'bar', 'baz', ['+', ['$', ''], 3]];
+        check(
+          expression,
+          {
+            foo: 'bar',
+            baz: 5,
+          },
+          2,
+        );
+      });
+
+      test('can retrieve object from input', () => {
+        const expression: Expr = ['o.set', ['$', '/obj'], 'foo', 123];
+        check(
+          expression,
+          {
+            type: 'the-obj',
+            foo: 123,
+          },
+          {
+            obj: {
+              type: 'the-obj',
+            },
+          },
+        );
+      });
+
+      test('can compute prop from expression', () => {
+        const expression: Expr = ['o.set', {a: 'b'}, ['.', ['$', '/name'], '_test'], ['+', 5, 5]];
+        check(
+          expression,
+          {
+            a: 'b',
+            Mac_test: 10,
+          },
+          {
+            name: 'Mac',
+          },
+        );
+      });
+
+      test('cannot set __proto__ prop', () => {
+        const expression: Expr = ['o.set', {a: 'b'}, '__proto__', ['$', '/name']];
+        expect(() =>
+          check(
+            expression,
+            {
+              a: 'b',
+              __proto__: 'Mac',
+            },
+            {
+              name: 'Mac',
+            },
+          ),
+        ).toThrow(new Error('PROTO_KEY'));
+      });
+    });
+
+    describe('o.del', () => {
+      test('can delete an object property', () => {
+        check(['o.del', {foo: 'bar', baz: 'qux'}, 'foo', 'bar'], {baz: 'qux'});
+      });
+
+      test('object can be an expression', () => {
+        check(['o.del', ['$', ''], 'a', 'c', 'd'], {b: 2}, {a: 1, b: 2, c: 3});
+      });
+
+      test('prop can be an expression', () => {
+        check(['o.del', {a: 1, b: 2, c: 3}, ['$', '']], {a: 1, c: 3}, 'b');
+      });
+
+      test('object and prop can be an expression', () => {
+        check(['o.del', ['$', '/o'], ['$', '/p']], {a: 1, c: 3}, {o: {a: 1, b: 2, c: 3}, p: 'b'});
+      });
+    });
   });
 
   describe('Branching operators', () => {
@@ -2198,4 +2280,24 @@ export const jsonExpressionUnitTests = (
       });
     });
   });
+
+  describe('JSON Patch operators', () => {
+    describe('jp.add', () => {
+      test('can set an object property', () => {
+        check(['jp.add', {}, '/foo', 'bar'], {foo: 'bar'});
+      });
+
+      test('can set two properties, one computed', () => {
+        const expression: Expr = ['jp.add', {}, '/foo', 'bar', '/baz', ['+', ['$', ''], 3]];
+        check(
+          expression,
+          {
+            foo: 'bar',
+            baz: 5,
+          },
+          2,
+        );
+      });
+    });
+  });
 };

src/json-expression/codegen.ts

@@ -91,6 +91,7 @@ export class JsonExpressionCodegen {
 
   public compile() {
     const fn = this.codegen.compile();
+    // console.log('fn', fn.toString());
     return (ctx: types.JsonExpressionExecutionContext) => {
       try {
         return fn(ctx);

src/json-expression/operators/index.ts

@@ -11,6 +11,7 @@ import {objectOperators} from './object';
 import {branchingOperators} from './branching';
 import {inputOperators} from './input';
 import {bitwiseOperators} from './bitwise';
+import {patchOperators} from './patch';
 
 export const operators = [
   ...arithmeticOperators,
@@ -25,6 +26,7 @@ export const operators = [
   ...branchingOperators,
   ...inputOperators,
   ...bitwiseOperators,
+  ...patchOperators,
 ];
 
 export const operatorsMap = operatorsToMap(operators);

src/json-expression/operators/object.ts

@@ -1,7 +1,22 @@
 import * as util from '../util';
-import {Expression, ExpressionResult} from '../codegen-steps';
+import {Expression, ExpressionResult, Literal} from '../codegen-steps';
 import type * as types from '../types';
 
+const validateSetOperandCount = (count: number) => {
+  if (count < 3) {
+    throw new Error('Not enough operands for "o.set".');
+  }
+  if (count % 2 !== 0) {
+    throw new Error('Invalid number of operands for "o.set" operand.');
+  }
+};
+
+const validateDelOperandCount = (count: number) => {
+  if (count < 3) {
+    throw new Error('Not enough operands for "o.del".');
+  }
+};
+
 export const objectOperators: types.OperatorDefinition<any>[] = [
   [
     'keys',
@@ -47,4 +62,109 @@ export const objectOperators: types.OperatorDefinition<any>[] = [
       return new Expression(js);
     },
   ] as types.OperatorDefinition<types.ExprEntries>,
+
+  [
+    'o.set',
+    [],
+    -1,
+    /**
+     * Set one or more properties on an object.
+     *
+     * ```
+     * ['o.set', {},
+     *   'a', 1,
+     *   'b', ['+', 2, 3],
+     * ]
+     * ```
+     *
+     * Results in:
+     *
+     * ```
+     * {
+     *   a: 1,
+     *   b: 5,
+     * }
+     * ```
+     */
+    (expr: types.ExprObjectSet, ctx) => {
+      let i = 1;
+      const length = expr.length;
+      validateSetOperandCount(length);
+      const doc = util.asObj(ctx.eval(expr[i++], ctx)) as Record<string, unknown>;
+      while (i < length) {
+        const prop = util.str(ctx.eval(expr[i++], ctx)) as string;
+        if (prop === '__proto__') throw new Error('PROTO_KEY');
+        const value = ctx.eval(expr[i++], ctx);
+        doc[prop] = value;
+      }
+      return doc;
+    },
+    (ctx: types.OperatorCodegenCtx<types.ExprObjectSet>): ExpressionResult => {
+      const length = ctx.operands.length;
+      validateSetOperandCount(length + 1);
+      let i = 0;
+      let curr = ctx.operands[i++];
+      if (curr instanceof Literal) {
+        curr = new Literal(util.asObj(curr.val));
+      } else if (curr instanceof Expression) {
+        ctx.link(util.asObj, 'asObj');
+        curr = new Expression(`asObj(${curr})`);
+      }
+      ctx.link(util.str, 'str');
+      ctx.link(util.objSetRaw, 'objSetRaw');
+      while (i < length) {
+        let prop = ctx.operands[i++];
+        if (prop instanceof Literal) {
+          prop = new Literal(util.str(prop.val));
+        } else if (prop instanceof Expression) {
+          prop = new Expression(`str(${prop})`);
+        }
+        const value = ctx.operands[i++];
+        curr = new Expression(`objSetRaw(${curr}, ${prop}, ${value})`);
+      }
+      return curr;
+    },
+  ] as types.OperatorDefinition<types.ExprObjectSet>,
+
+  [
+    'o.del',
+    [],
+    -1,
+    /**
+     * Delete one or more properties from an object.
+     *
+     * ```
+     * ['o.del', {}, 'prop1', 'prop2']
+     * ```
+     */
+    (expr: types.ExprObjectSet, ctx) => {
+      let i = 1;
+      const length = expr.length;
+      validateDelOperandCount(length);
+      const doc = util.asObj(ctx.eval(expr[i++], ctx)) as Record<string, unknown>;
+      while (i < length) {
+        const prop = util.str(ctx.eval(expr[i++], ctx)) as string;
+        delete doc[prop];
+      }
+      return doc;
+    },
+    (ctx: types.OperatorCodegenCtx<types.ExprObjectSet>): ExpressionResult => {
+      const length = ctx.operands.length;
+      validateDelOperandCount(length + 1);
+      let i = 0;
+      let curr = ctx.operands[i++];
+      ctx.link(util.str, 'str');
+      ctx.link(util.objDelRaw, 'objDelRaw');
+      while (i < length) {
+        let prop = ctx.operands[i++];
+        if (prop instanceof Literal) {
+          prop = new Literal(util.str(prop.val));
+        } else if (prop instanceof Expression) {
+          prop = new Expression(`str(${prop})`);
+        }
+        curr = new Expression(`objDelRaw(${curr}, ${prop})`);
+      }
+      return curr;
+    },
+  ] as types.OperatorDefinition<types.ExprObjectSet>,
 ];

src/json-expression/operators/patch.ts

@@ -0,0 +1,114 @@
+import {Expression, ExpressionResult} from '../codegen-steps';
+import type * as types from '../types';
+import {Path, toPath} from '../../json-pointer';
+import {JavaScript, JavaScriptLinked, compileClosure} from '@jsonjoy.com/util/lib/codegen';
+import {$findRef} from '../../json-pointer/codegen/findRef';
+import {find} from '../../json-pointer/find';
+
+const validateAddOperandCount = (count: number) => {
+  if (count < 3) {
+    throw new Error('Not enough operands for "jp.add" operand.');
+  }
+  if (count % 2 !== 0) {
+    throw new Error('Invalid number of operands for "jp.add" operand.');
+  }
+};
+
+const validateAddPath = (path: unknown) => {
+  if (typeof path !== 'string') {
+    throw new Error('The "path" argument for "jp.add" must be a const string.');
+  }
+};
+
+type AddFn = (doc: unknown, value: unknown) => unknown;
+
+export const $$add = (path: Path): JavaScriptLinked<AddFn> => {
+  const find = $findRef(path);
+  const js = /* js */ `
+(function(find, path){
+  return function(doc, value){
+    var f = find(doc);
+    var obj = f.obj, key = f.key, val = f.val;
+    if (!obj) doc = value;
+    else if (typeof key === 'string') obj[key] = value;
+    else {
+      var length = obj.length;
+      if (key < length) obj.splice(key, 0, value);
+      else if (key > length) throw new Error('INVALID_INDEX');
+      else obj.push(value);
+    }
+    return doc;
+  };
+})`;
+
+  return {
+    deps: [find] as unknown[],
+    js: js as JavaScript<(...deps: unknown[]) => AddFn>,
+  };
+};
+
+export const $add = (path: Path): AddFn => compileClosure($$add(path));
+
+export const patchOperators: types.OperatorDefinition<any>[] = [
+  [
+    'jp.add',
+    [],
+    -1,
+    /**
+     * Applies JSON Patch "add" operations to the input value.
+     *
+     * ```
+     * ['add', {},
+     *   '/a', 1,
+     *   '/b', ['+', 2, 3],
+     * ]
+     * ```
+     *
+     * Results in:
+     *
+     * ```
+     * {
+     *   a: 1,
+     *   b: 5,
+     * }
+     * ```
+     */
+    (expr: types.JsonPatchAdd, ctx) => {
+      let i = 1;
+      const length = expr.length;
+      validateAddOperandCount(length);
+      let doc = ctx.eval(expr[i++], ctx);
+      while (i < length) {
+        const path = expr[i++];
+        validateAddPath(path);
+        const value = ctx.eval(expr[i++], ctx);
+        const {obj, key} = find(doc, toPath(path));
+        if (!obj) doc = value;
+        else if (typeof key === 'string') (obj as any)[key] = value;
+        else if (obj instanceof Array) {
+          const length = obj.length;
+          if ((key as number) < length) obj.splice(key as number, 0, value);
+          else if ((key as number) > length) throw new Error('INVALID_INDEX');
+          else obj.push(value);
+        }
+      }
+      return doc;
+    },
+    (ctx: types.OperatorCodegenCtx<types.JsonPatchAdd>): ExpressionResult => {
+      const expr = ctx.expr;
+      const length = ctx.operands.length;
+      validateAddOperandCount(length + 1);
+      let i = 0;
+      let curr = ctx.operands[i++];
+      while (i < length) {
+        const path = expr[1 + i++];
+        validateAddPath(path);
+        const value = ctx.operands[i++];
+        const addCompiled = $add(toPath(path));
+        const dAdd = ctx.link(addCompiled);
+        curr = new Expression(`${dAdd}(${curr}, ${value})`);
+      }
+      return curr;
+    },
+  ] as types.OperatorDefinition<types.JsonPatchAdd>,
+];