@player-tools/dsl 0.11.0 → 0.12.1--canary.213.4811

package/src/__tests__/util.test.tsx

@@ -1,12 +1,20 @@
 import { test, expect, describe } from "vitest";
-import { getObjectReferences } from "../utils";
+import {
+  getObjectReferences,
+  makeFunctionByName,
+  mapExpressionHandlersToFunctions,
+  wrapFunctionInType,
+} from "../utils";
+import { Binding, Expression, ExpressionHandler } from "@player-ui/player";
+import { binding, expression } from "../string-templates";
+import { LocalBazType } from "./helpers/mock-data-refs";
+import { DataTypeRefs } from "../types";
+import { makeBindingsForObject } from "../compiler/schema";
 
 describe("Testing the 'getObjectReferences' helper that creates same property references into a new object", () => {
   test("should return the object properties in referenced format", () => {
     const dataTypes = {
-      BooleanType: {
-        type: "BooleanType",
-      },
+      LocalBazType,
     };
 
     const validators = {
@@ -15,12 +23,192 @@ describe("Testing the 'getObjectReferences' helper that creates same property re
       },
     };
 
-    const dataReferences = getObjectReferences(dataTypes);
-    const validatorReferences = getObjectReferences(validators);
+    type DTREF = DataTypeRefs<typeof dataTypes>;
+
+    const dataReferences = getObjectReferences<typeof dataTypes, DTREF>(
+      dataTypes,
+    );
 
-    expect(dataReferences.BooleanTypeRef).toStrictEqual({
-      type: "BooleanType",
+    type VALREF = DataTypeRefs<typeof validators>;
+    const validatorReferences = getObjectReferences<typeof validators, VALREF>(
+      validators,
+    );
+
+    expect(dataReferences.LocalBazTypeRef).toStrictEqual({
+      type: "LocalBazType",
     });
     expect(validatorReferences.requiredRef).toStrictEqual({ type: "required" });
   });
 });
+
+describe("DSL Expression Generation Helper", () => {
+  test("Returns the correct serialization for bindings", () => {
+    const mockFunction: ExpressionHandler<[Binding], boolean> = (ctx, val) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding<string>`some.binding`;
+    const test = expression`${mockFunctionDSL(foo)} == true`;
+
+    expect(test.toValue()).toEqual("mockFunction('some.binding') == true");
+  });
+
+  test("Returns the correct serialization for mixed values and bindings", () => {
+    const mockFunction: ExpressionHandler<[string, string, number], boolean> = (
+      ctx,
+      val,
+    ) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding<string>`some.binding`;
+    const test = expression`${mockFunctionDSL(foo.toRefString(), "test", 1)} == true`;
+
+    expect(test.toValue()).toEqual(
+      "mockFunction('{{some.binding}}', 'test', 1) == true",
+    );
+  });
+
+  test("Returns the correct serialization for array items", () => {
+    const mockFunction: ExpressionHandler<[Array<unknown>], boolean> = (
+      ctx,
+      val,
+    ) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding`some.binding`;
+    const test = expression`${mockFunctionDSL([1, "2", foo])}`;
+
+    expect(test.toValue()).toEqual(
+      "mockFunction([1, '2', '{{some.binding}}'])",
+    );
+  });
+
+  test("Can Dereferenced Binding", () => {
+    const mockFunction: ExpressionHandler<[boolean], boolean> = (ctx, val) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding<boolean>`some.binding`;
+    const test = expression`${mockFunctionDSL(foo.toRefString())} == true`;
+
+    expect(test.toValue()).toEqual("mockFunction('{{some.binding}}') == true");
+  });
+
+  test("Can Pass Nested Expressions", () => {
+    const mockFunction: ExpressionHandler<[Expression, number], boolean> = (
+      ctx,
+      val,
+    ) => {
+      return false;
+    };
+
+    const mockFunctionDSL = wrapFunctionInType(mockFunction);
+
+    const foo = binding`foo.bar`;
+    const bar = expression<string>`${foo} != 1`;
+    const test = expression`${mockFunctionDSL(bar, 1)}`;
+
+    expect(test.toValue()).toEqual("mockFunction('{{foo.bar}} != 1', 1)");
+  });
+
+  test("Mock a function by name and args", () => {
+    const testFunction = makeFunctionByName<[string, number, boolean], void>(
+      "testFunction",
+    );
+
+    expect(testFunction("1", 0, false).toValue()).toMatch(
+      "testFunction('1', 0, false)",
+    );
+  });
+
+  test("Export Generator", () => {
+    const mockFunction: ExpressionHandler<[string, number], boolean> = (
+      ctx,
+      val,
+    ) => {
+      return false;
+    };
+    const expressionFunctions = { mockFunction };
+
+    const usableFunctions =
+      mapExpressionHandlersToFunctions<typeof expressionFunctions>(
+        expressionFunctions,
+      );
+
+    expect(usableFunctions.mockFunction("1", 0).toValue()).toMatch(
+      "mockFunction('1', 0)",
+    );
+  });
+
+  test("Return Type Chaining", () => {
+    const mockFunction: ExpressionHandler<[string, number], string> = (
+      ctx,
+      val,
+    ) => {
+      return "false";
+    };
+
+    const mockFunction2: ExpressionHandler<[string], boolean> = (ctx, val) => {
+      return false;
+    };
+    const expressionFunctions = { mockFunction, mockFunction2 };
+
+    const usableFunctions =
+      mapExpressionHandlersToFunctions<typeof expressionFunctions>(
+        expressionFunctions,
+      );
+
+    expect(
+      usableFunctions
+        .mockFunction2(usableFunctions.mockFunction("1", 0).toValue())
+        .toValue(),
+    ).toMatch("mockFunction2('mockFunction('1', 0)')");
+  });
+
+  test("Works with DSL Schema", () => {
+    const mockFunction: ExpressionHandler<[string, boolean], string> = (
+      ctx,
+      val,
+    ) => {
+      return "false";
+    };
+
+    const dataTypes = { LocalBazType };
+
+    type DTREF = DataTypeRefs<typeof dataTypes>;
+
+    const refableTypes = getObjectReferences<typeof dataTypes, DTREF>(
+      dataTypes,
+    );
+
+    const data = {
+      some: {
+        value: refableTypes.LocalBazTypeRef,
+      },
+    };
+
+    const schema = makeBindingsForObject(data);
+    const expressionFunctions = { mockFunction };
+
+    const usableFunctions =
+      mapExpressionHandlersToFunctions<typeof expressionFunctions>(
+        expressionFunctions,
+      );
+
+    expect(
+      usableFunctions
+        .mockFunction("1", schema.some.value.toRefString())
+        .toValue(),
+    ).toMatch("mockFunction('1', '{{some.value}}')");
+  });
+});

package/src/compiler/schema.ts

@@ -8,7 +8,7 @@ import type { BindingTemplateInstance } from "../string-templates";
 const bindingSymbol = Symbol("binding");
 
 /** Symbol to indicate that a schema node should be generated with a different name */
-export const SchemaTypeName = Symbol("Schema Rename");
+export const SchemaTypeName: unique symbol = Symbol("Schema Rename");
 
 interface SchemaChildren {
   /** Object property that will be used to create the intermediate type */
@@ -47,7 +47,15 @@ export class SchemaGenerator {
   private generatedDataTypes: Map<string, GeneratedDataType>;
   private logger: LoggingInterface;
 
-  public hooks = {
+  public hooks: {
+    createSchemaNode: SyncWaterfallHook<
+      [
+        node: Schema.DataType<unknown>,
+        originalProperty: Record<string | symbol, unknown>,
+      ],
+      Record<string, any>
+    >;
+  } = {
     createSchemaNode: new SyncWaterfallHook<
       [
         node: Schema.DataType,
@@ -197,14 +205,14 @@ export type MakeBindingRefable<T> = {
     : T[P] extends unknown[]
       ? T[P]
       : MakeBindingRefable<T[P]>;
-} & BindingTemplateInstance;
+} & BindingTemplateInstance<T>;
 
 /**
  * Adds bindings to an object so that the object can be directly used in JSX
  */
 export function makeBindingsForObject<Type>(
   obj: Type,
-  arrayAccessorKeys = ["_index_"],
+  arrayAccessorKeys: string[] = ["_index_"],
 ): MakeBindingRefable<Type> {
   /** Proxy to track binding callbacks */
   const accessor = (paths: string[]) => {
@@ -258,7 +266,7 @@ export function makeBindingsForObject<Type>(
 /**
  * Generates binding for an object property
  */
-export const getBindingFromObject = (obj: any) => {
+export const getBindingFromObject = (obj: any): BindingTemplateInstance => {
   const baseBindings = obj[bindingSymbol] as string[];
   if (!Array.isArray(baseBindings) || baseBindings.length === 0) {
     throw new Error(`Unable to get binding for ${obj}`);
@@ -270,13 +278,13 @@ export const getBindingFromObject = (obj: any) => {
 /**
  * Returns the binding string from an object path
  */
-export const getBindingStringFromObject = (obj: any) => {
+export const getBindingStringFromObject = (obj: any): string => {
   return getBindingFromObject(obj).toString();
 };
 
 /**
  * Returns the ref string from an object path
  */
-export const getRefStringFromObject = (obj: any) => {
+export const getRefStringFromObject = (obj: any): string => {
   return getBindingFromObject(obj).toRefString();
 };

package/src/expressions/__tests__/native.test.ts

@@ -0,0 +1,159 @@
+import { test, expect, describe } from "vitest";
+import {
+  and,
+  assign,
+  binding as b,
+  expression as e,
+  equals,
+  nand,
+  nor,
+  not,
+  or,
+} from "../..";
+
+describe("assign", () => {
+  test("string", () => {
+    const binding = b`foo.bar`;
+    expect(assign(binding, "1").toValue()).toStrictEqual("{{foo.bar}} = '1'");
+  });
+  test("number", () => {
+    const binding = b`foo.bar`;
+    expect(assign(binding, 1).toValue()).toStrictEqual("{{foo.bar}} = 1");
+  });
+  test("boolean", () => {
+    const binding = b`foo.bar`;
+    expect(assign(binding, true).toValue()).toStrictEqual("{{foo.bar}} = true");
+  });
+  test("undefined", () => {
+    const binding = b`foo.bar`;
+    expect(assign(binding, undefined).toValue()).toStrictEqual(
+      "{{foo.bar}} = null",
+    );
+  });
+});
+
+describe("not", () => {
+  test("binding", () => {
+    const binding = b<boolean>`foo.bar`;
+    expect(not(binding).toValue()).toStrictEqual("!({{foo.bar}})");
+  });
+  test("expression", () => {
+    const expression = e<boolean>`${b`foo.bar`} = true`;
+
+    expect(not(expression).toValue()).toStrictEqual("!({{foo.bar}} = true)");
+  });
+});
+
+describe("and", () => {
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(and(binding, binding2).toValue()).toStrictEqual(
+      "{{foo.bar}} && {{foo.baz}}",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(and(expression, expression2).toValue()).toStrictEqual(
+      "({{foo.bar}} == true) && ({{foo.baz}} == '1')",
+    );
+  });
+});
+
+describe("or", () => {
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(or(binding, binding2).toValue()).toStrictEqual(
+      "{{foo.bar}} || {{foo.baz}}",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(or(expression, expression2).toValue()).toStrictEqual(
+      "({{foo.bar}} == true) || ({{foo.baz}} == '1')",
+    );
+  });
+});
+
+describe("nand", () => {
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(nand(binding, binding2).toValue()).toStrictEqual(
+      "!({{foo.bar}} && {{foo.baz}})",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(nand(expression, expression2).toValue()).toStrictEqual(
+      "!(({{foo.bar}} == true) && ({{foo.baz}} == '1'))",
+    );
+  });
+});
+
+describe("nor", () => {
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(nor(binding, binding2).toValue()).toStrictEqual(
+      "!({{foo.bar}} || {{foo.baz}})",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(nor(expression, expression2).toValue()).toStrictEqual(
+      "!(({{foo.bar}} == true) || ({{foo.baz}} == '1'))",
+    );
+  });
+});
+
+describe("equals", () => {
+  test("binding-string", () => {
+    const binding = b`foo.bar`;
+    expect(equals(binding, "1").toValue()).toStrictEqual("{{foo.bar}} == '1'");
+  });
+
+  test("binding-number", () => {
+    const binding = b`foo.bar`;
+    expect(equals(binding, 1).toValue()).toStrictEqual("{{foo.bar}} == 1");
+  });
+
+  test("binding-boolean", () => {
+    const binding = b`foo.bar`;
+    expect(equals(binding, true).toValue()).toStrictEqual(
+      "{{foo.bar}} == true",
+    );
+  });
+
+  test("binding-undefined", () => {
+    const binding = b`foo.bar`;
+    expect(equals(binding, undefined).toValue()).toStrictEqual(
+      "{{foo.bar}} == null",
+    );
+  });
+
+  test("bindings", () => {
+    const binding = b<boolean>`foo.bar`;
+    const binding2 = b<boolean>`foo.baz`;
+    expect(equals(binding, binding2).toValue()).toStrictEqual(
+      "{{foo.bar}} == {{foo.baz}}",
+    );
+  });
+
+  test("expressions", () => {
+    const expression = e<boolean>`${b`foo.bar`} == true`;
+    const expression2 = e<boolean>`${b`foo.baz`} == '1'`;
+    expect(equals(expression, expression2).toValue()).toStrictEqual(
+      "({{foo.bar}} == true) == ({{foo.baz}} == '1')",
+    );
+  });
+});

package/src/expressions/__tests__/testing.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "vitest";
+import { expression as e } from "../../string-templates";
+import { testExpression } from "../testing";
+import { ExpressionHandler, withoutContext } from "@player-ui/player";
+
+describe("expression testing", () => {
+  const initialModel = {
+    foo: {
+      bar: {
+        a: "1",
+        b: 2,
+        c: false,
+      },
+    },
+  };
+
+  test("basic operations", () => {
+    const exp = e`{{foo.bar.a}} = "test"`;
+    const result = testExpression(exp, initialModel);
+    expect(result).toStrictEqual({
+      foo: { bar: { a: "test", b: 2, c: false } },
+    });
+  });
+
+  test("custom function", () => {
+    const exp = e`{{foo.bar.c}} = not({{foo.bar.c}})`;
+
+    const mockExpression: ExpressionHandler<[boolean], boolean> =
+      withoutContext((arg) => {
+        return !arg;
+      });
+    const expressionMap = new Map([["not", mockExpression]]);
+    const result = testExpression(exp, initialModel, expressionMap);
+    expect(result).toStrictEqual({
+      foo: { bar: { a: "1", b: 2, c: true } },
+    });
+  });
+});

package/src/expressions/native.ts

@@ -0,0 +1,141 @@
+import {
+  expression as e,
+  BindingTemplateInstance,
+  ExpressionTemplateInstance,
+  isTemplateStringInstance,
+  isBindingTemplateInstance,
+} from "..";
+
+type Argument<T> =
+  | string
+  | boolean
+  | number
+  | undefined
+  | BindingTemplateInstance<T>
+  | ExpressionTemplateInstance<T>;
+
+const escapePrimitive = <T>(
+  val: Exclude<
+    Argument<T>,
+    BindingTemplateInstance<T> | ExpressionTemplateInstance<T>
+  >,
+): string => {
+  switch (typeof val) {
+    case "string": {
+      return `'${val}'`;
+    }
+    case "undefined": {
+      return "null";
+    }
+    default: {
+      return `${val}`;
+    }
+  }
+};
+
+const handleBindingOrExpression = (
+  val: BindingTemplateInstance | ExpressionTemplateInstance,
+) => {
+  if (isBindingTemplateInstance(val)) {
+    return val.toRefString();
+  } else {
+    return `(${val.toValue()})`;
+  }
+};
+
+const handleArgument = <T>(arg: Argument<T>): string => {
+  return isTemplateStringInstance(arg)
+    ? handleBindingOrExpression(arg)
+    : escapePrimitive(arg);
+};
+
+/**
+ * Performs an assigment of a value to a binding by returning the expression
+ * {{<binding>}} = <value>
+ * @param binding
+ * @param value
+ */
+export const assign = <T>(
+  binding: BindingTemplateInstance<any>,
+  value: Argument<T>,
+): ExpressionTemplateInstance<void> => {
+  return e`${binding} = ${isTemplateStringInstance(value) ? value : escapePrimitive(value)}`;
+};
+
+/**
+ * Returns an equality comparison between the two values
+ */
+export const equals = <A, B>(
+  a: Argument<A>,
+  b: Argument<B>,
+): ExpressionTemplateInstance<boolean> => {
+  return e`${handleArgument(a)} == ${handleArgument(b)}`;
+};
+
+/**
+ * Returns the negated version of the binding/expression
+ * by returning !(<value>)
+ * @param binding Binding/Expression to invert
+ * @returns Negated binding/expression
+ */
+export const not = (
+  value: BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>,
+): ExpressionTemplateInstance<boolean> => {
+  return e<boolean>`!(${value})`;
+};
+
+/**
+ * Creates an expression for the logical or'ing of the provided values
+ * e.g: <exp1> || <exp2> || ...
+ * @param values Array of bindings/expressions to logically or
+ * @returns boolean
+ */
+export const or = (
+  ...values: Array<
+    BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>
+  >
+): ExpressionTemplateInstance<boolean> => {
+  return e`${values.map(handleBindingOrExpression).join(" || ")}` as ExpressionTemplateInstance<boolean>;
+};
+
+/**
+ * Creates an expression for the logical nor'ing of the provided values
+ * e.g: !(<exp1> || <exp2> || ...)
+ * @param values Array of bindings/expressions to logically nor
+ * @returns boolean
+ */
+export const nor = (
+  ...values: Array<
+    BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>
+  >
+): ExpressionTemplateInstance<boolean> => {
+  return not(or(...values));
+};
+
+/**
+ * Creates an expression for the logical and'ing of the provided values
+ * e.g: <exp1> && <exp2> && ...
+ * @param values Array of bindings/expressions to logically and
+ * @returns boolean
+ */
+export const and = (
+  ...values: Array<
+    BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>
+  >
+): ExpressionTemplateInstance<boolean> => {
+  return e`${values.map(handleBindingOrExpression).join(" && ")}` as ExpressionTemplateInstance<boolean>;
+};
+
+/**
+ * Creates an expression for the logical nand'ing of the provided values
+ * e.g: !(<exp1> && <exp2> && ...)
+ * @param values Array of bindings/expressions to logically nand
+ * @returns boolean
+ */
+export const nand = (
+  ...values: Array<
+    BindingTemplateInstance<boolean> | ExpressionTemplateInstance<boolean>
+  >
+): ExpressionTemplateInstance<boolean> => {
+  return not(and(...values));
+};

package/src/expressions/testing.ts

@@ -0,0 +1,40 @@
+import {
+  BindingParser,
+  ExpressionEvaluator,
+  ExpressionHandler,
+  ExpressionType,
+  LocalModel,
+  withParser,
+} from "@player-ui/player";
+import { ExpressionTemplateInstance } from "../string-templates";
+
+/**
+ * Test harness to make testing expressions easier.
+ * Given an expreesion and an initial data model the harness will execute the expression
+ * on and return the new state of the data model.
+ * @param exp expression to execute
+ * @param initialData data model to operate on
+ * @param expressions expression handlers for functions that are called
+ * @returns Final data model state
+ */
+export function testExpression(
+  exp: ExpressionTemplateInstance,
+  initialData: object,
+  expressions?: Map<string, ExpressionHandler<any[], any>>,
+): object {
+  // Setup Mock Player model and parsers
+  const localModel = new LocalModel(initialData);
+  const bindingParser = new BindingParser({
+    get: localModel.get,
+    set: localModel.set,
+    evaluate: (exp: ExpressionType) => {
+      return evaluator.evaluate(exp);
+    },
+  });
+
+  const model = withParser(localModel, bindingParser.parse);
+  const evaluator = new ExpressionEvaluator({ model });
+  expressions?.forEach((fn, name) => evaluator.addExpressionFunction(name, fn));
+  evaluator.evaluate(exp.toValue());
+  return localModel.get();
+}

package/src/index.ts

@@ -9,3 +9,4 @@ export * from "react-json-reconciler";
 export * from "./compiler/schema";
 export * from "./compiler";
 export * from "./compiler/types";
+export * from "./expressions/native";