@valbuild/core 0.12.0 → 0.13.1

package/src/selector/ExprProxy.test.ts

@@ -0,0 +1,203 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { convertLiteralProxy, newExprSelectorProxy } from "./ExprProxy";
+import * as expr from "../expr/expr";
+import { GenericSelector, SelectorSource, SourceOrExpr } from ".";
+import { Source } from "../source";
+
+const ExprSelectorTestCases: any[] = [
+  {
+    description: "basic module",
+    input: newExprSelectorProxy<string>(root("/app/foo")),
+    expected: "(val '/app/foo')",
+  },
+  {
+    description: "basic prop",
+    input: newExprSelectorProxy<string[]>(root("/app/foo"))[0],
+    expected: "('0' (val '/app/foo'))",
+  },
+  {
+    description: "noop andThen",
+    input: newExprSelectorProxy<string>(root("/app/foo")).andThen((v) => v),
+    expected: "!(andThen (val '/app/foo') @[0,0])",
+  },
+  {
+    description: "noop map",
+    input: newExprSelectorProxy<string[]>(root("/app/foo")).map((v) => v),
+    expected: "!(map (val '/app/foo') @[0,0])",
+  },
+  {
+    description: "eq string",
+    input: newExprSelectorProxy<string>(root("/app/foo")).eq("hei"),
+    expected: "(eq (val '/app/foo') 'hei')",
+  },
+  {
+    description: "eq undefined",
+    input: newExprSelectorProxy<null>(root("/app/foo")).eq(null),
+    expected: "(eq (val '/app/foo') ())",
+  },
+  {
+    description: "eq number",
+    input: newExprSelectorProxy<number>(root("/app/foo")).eq(1),
+    expected: "(eq (val '/app/foo') (json '1'))",
+  },
+  {
+    description: "eq boolean",
+    input: newExprSelectorProxy<boolean>(root("/app/foo")).eq(true),
+    expected: "(eq (val '/app/foo') (json 'true'))",
+  },
+  {
+    description: "filter string",
+    input: newExprSelectorProxy<string[]>(root("/app/foo")).filter((v) =>
+      v.eq("hei")
+    ),
+    expected: "!(filter (val '/app/foo') (eq @[0,0] 'hei'))",
+  },
+  {
+    description: "filter number",
+    input: newExprSelectorProxy<number[]>(root("/app/foo")).filter((v) =>
+      v.eq(1)
+    ),
+    expected: "!(filter (val '/app/foo') (eq @[0,0] (json '1')))",
+  },
+  {
+    description: "filter optional",
+    input: newExprSelectorProxy<number[]>(root("/app/foo")).filter((v) =>
+      v.eq(null)
+    ),
+    expected: "!(filter (val '/app/foo') (eq @[0,0] ()))",
+  },
+  {
+    description: "basic projection",
+    input: newExprSelectorProxy<string[]>(root("/app/foo")).map((v) => ({
+      foo: v,
+    })),
+    expected: "!(map (val '/app/foo') (json '{\"foo\": ${@[0,0]}}'))",
+  },
+  {
+    description: "nested projection",
+    input: newExprSelectorProxy<string[]>(root("/app/foo")).map((v) => ({
+      foo: {
+        bar: v,
+      },
+    })),
+    expected:
+      // TODO: this could be more readable
+      // Example: "!(map (val '/app/foo') (json '{\"foo\": {\"bar\": {${@[0,0]}}'}'))"
+      "!(map (val '/app/foo') (json '{\"foo\": ${'{\"bar\": ${@[0,0]}}'}}'))",
+  },
+  {
+    description: "multi module",
+    input: newExprSelectorProxy<string>(root("/app/foo")).andThen(() =>
+      newExprSelectorProxy<string[]>(root("/app/bar"))
+    ),
+    expected: "!(andThen (val '/app/foo') (val '/app/bar'))",
+  },
+];
+
+/**
+ * Useful test cases for literal conversion
+ * There somewhat of an overlap between these cases and the selector cases,
+ * we could prune some of these away if we want to
+ **/
+const LiteralConversionTestCases: {
+  input: SelectorSource;
+  expected: string;
+  description: string;
+}[] = [
+  { description: "basic string", input: "foo", expected: "(json '\"foo\"')" },
+  { description: "basic number", input: 1, expected: "(json '1')" },
+  { description: "basic boolean", input: true, expected: "(json 'true')" },
+  { description: "basic array", input: [1], expected: "(json '[1]')" },
+  { description: "basic null", input: null, expected: "()" },
+  {
+    description: "array with 2 different",
+    input: [1, "foo"],
+    expected: "(json '[1, \"foo\"]')",
+  },
+  {
+    description: "array with undefined",
+    input: [1, null],
+    expected: "(json '[1, ${()}]')",
+  },
+  {
+    description: "basic object",
+    input: { foo: "one", bar: 1 },
+    expected: '(json \'{"foo": "one", "bar": 1}\')',
+  },
+  {
+    description: "nested array",
+    input: [1, [1]],
+    expected: "(json '[1, [1]]')",
+  },
+  {
+    description: "nested object",
+    input: { foo: "one", bar: { zoo: 1 } },
+    expected: '(json \'{"foo": "one", "bar": {"zoo": 1}}\')',
+  },
+  {
+    description: "nested object with array",
+    input: {
+      foo: "one",
+      bar: { zoo: [1, "inner"] },
+    },
+    expected: '(json \'{"foo": "one", "bar": {"zoo": [1, "inner"]}}\')',
+  },
+  {
+    description: "basic interpolation",
+    input: [1, newExprSelectorProxy<string[]>(root("/app/foo"))],
+    expected: "(json '[1, ${(val '/app/foo')}]')",
+  },
+  {
+    description: "advanced interpolation",
+    input: [
+      123,
+      newExprSelectorProxy<string[]>(root("/app/foo")).map((v) =>
+        v.andThen((a) => ({ bar: a.eq("bar") }))
+      ),
+    ],
+    expected:
+      "(json '[123, ${!(map (val '/app/foo') !(andThen @[0,0] (json '{\"bar\": ${(eq @[1,0] 'bar')}}')))}]')",
+  },
+  {
+    description: "interpolation with multiple selectors",
+    input: [
+      123,
+      newExprSelectorProxy<string[]>(root("/app/foo")).map((v) =>
+        v.andThen((a) => ({
+          bar: a.eq("bar"),
+          more: newExprSelectorProxy<string[]>(root("/app/foo")),
+        }))
+      ),
+    ],
+    expected:
+      "(json '[123, ${!(map (val '/app/foo') !(andThen @[0,0] (json '{\"bar\": ${(eq @[1,0] 'bar')}, \"more\": ${(val '/app/foo')}}')))}]')",
+  },
+];
+
+describe("expr", () => {
+  test.each(ExprSelectorTestCases)(
+    'expr selector ($description): "$expected"',
+    ({ input, expected }) => {
+      const valOrExpr = (input as unknown as GenericSelector<Source>)[
+        SourceOrExpr
+      ];
+      if (valOrExpr instanceof expr.Expr) {
+        expect(valOrExpr.transpile()).toBe(expected);
+      } else {
+        expect(valOrExpr).toBe(expect.any(expr.Expr));
+      }
+    }
+  );
+  test.each(LiteralConversionTestCases)(
+    'literal conversion ($description): "$expected"',
+    ({ input, expected }) =>
+      expect(convertLiteralProxy(input).transpile()).toBe(expected)
+  );
+});
+
+function root(sourcePath: string) {
+  return new expr.Call(
+    [new expr.Sym("val"), new expr.StringLiteral(sourcePath)],
+    false
+  );
+}

package/src/selector/ExprProxy.ts

@@ -0,0 +1,209 @@
+import { Selector, SelectorSource, SourceOrExpr } from ".";
+import * as expr from "../expr/expr";
+import { Source, SourcePrimitive } from "../source";
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyFun = (...args: any[]) => any;
+
+export function newExprSelectorProxy<T extends Source>(
+  root: expr.Expr,
+  depth = 0
+): Selector<T> {
+  return new Proxy(new GenericExprSelector(root, depth), {
+    get: (target, prop) => {
+      if (prop === SourceOrExpr) {
+        return target[SourceOrExpr];
+      }
+      if (!hasOwn(target, prop)) {
+        return newExprSelectorProxy(
+          new expr.Call([new expr.StringLiteral(prop.toString()), root], false),
+          depth
+        );
+      }
+      return Reflect.get(target, prop);
+    },
+  }) as unknown as Selector<T>;
+}
+
+class GenericExprSelector {
+  [SourceOrExpr]: expr.Expr;
+  constructor(private readonly root: expr.Expr, private readonly depth = 0) {
+    this[SourceOrExpr] = root;
+  }
+
+  andThen = (f: AnyFun) => {
+    return genericHigherOrderFunction(this.root, "andThen", f, 1, this.depth);
+  };
+
+  map = (f: AnyFun) => {
+    return genericHigherOrderFunction(this.root, "map", f, 2, this.depth);
+  };
+
+  filter = (f: AnyFun) => {
+    return genericHigherOrderFunction(this.root, "filter", f, 1, this.depth);
+  };
+
+  eq = (other: SourcePrimitive) => {
+    return newExprSelectorProxy(
+      new expr.Call(
+        [
+          new expr.Sym("eq"),
+          this.root,
+          typeof other === "string"
+            ? new expr.StringLiteral(other)
+            : typeof other === "undefined"
+            ? expr.NilSym
+            : convertLiteralProxy(other),
+        ],
+        false
+      ),
+      this.depth
+    );
+  };
+}
+
+function genericHigherOrderFunction(
+  root: expr.Expr,
+  name: string,
+  f: AnyFun,
+  args: number,
+  depth: number
+) {
+  const argsExprs: Selector<Source>[] = [];
+  for (let i = 0; i < args; i++) {
+    argsExprs.push(
+      newExprSelectorProxy(new expr.Sym(`@[${depth},${i}]`), depth + 1)
+    );
+  }
+  return newExprSelectorProxy(
+    new expr.Call(
+      [new expr.Sym(name), root, convertLiteralProxy(f(...argsExprs))],
+      true
+    ),
+    depth
+  );
+}
+
+function hasOwn<T extends PropertyKey>(obj: object, prop: T): boolean {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+export function convertLiteralProxy(
+  source: expr.Expr | SelectorSource
+): expr.Expr {
+  const [convertedLiteral] = convertObjectToStringExpr(source, true);
+  return withJsonCall(convertedLiteral, false)[0];
+}
+
+/**
+ * Add a json call if the literal must be parsed
+ * Happens at the very least at the top level, but may also happen inside e.g. a string template
+ *
+ */
+function withJsonCall(
+  e: expr.Expr,
+  isLiteralScope: boolean
+): [e: expr.Expr, isJson: boolean] {
+  if (
+    !isLiteralScope &&
+    (e instanceof expr.StringLiteral || e instanceof expr.StringTemplate)
+  ) {
+    return [new expr.Call([new expr.Sym("json"), e], false), true];
+  }
+  return [e, false];
+}
+
+function convertObjectToStringExpr(
+  source: expr.Expr | SelectorSource,
+  isLiteralScope: boolean
+): [e: expr.Expr, isJson: boolean] {
+  if (source === null || source === undefined) {
+    return [expr.NilSym, true];
+  } else if (typeof source === "string") {
+    return [new expr.StringLiteral(JSON.stringify(source)), false];
+  } else if (typeof source === "number" || typeof source === "boolean") {
+    return withJsonCall(
+      new expr.StringLiteral(source.toString()),
+      isLiteralScope
+    );
+  } else if (typeof source === "object" && SourceOrExpr in source) {
+    const selector = source;
+    const valOrExpr = selector[SourceOrExpr];
+    if (valOrExpr instanceof expr.Expr) {
+      return [valOrExpr, true];
+    } else {
+      // use Val literal - UNTESTED - may happen if we are referencing local content
+      return convertObjectToStringExpr(valOrExpr, isLiteralScope);
+    }
+  } else if (source instanceof expr.Expr) {
+    return [source, true];
+  } else if (typeof source === "object") {
+    // source is a literal object or array, might have nested selectors
+    const isArray = Array.isArray(source);
+    const entries = isArray
+      ? Array.from(source.entries())
+      : Object.entries(source);
+
+    let isStringTemplate = false;
+    const converted = entries.map(([key, v]) => {
+      const [converted, mustInterpolate] =
+        typeof v === "string"
+          ? withJsonCall(
+              new expr.StringLiteral(JSON.stringify(v)),
+              isLiteralScope
+            )
+          : convertObjectToStringExpr(v, isLiteralScope);
+
+      isStringTemplate = isStringTemplate || mustInterpolate;
+      return [key, converted] as const;
+    });
+
+    if (!isStringTemplate) {
+      const value = isArray
+        ? `[${converted.map(([, v]) => getStringLiteralValue(v)).join(", ")}]`
+        : `{${converted
+            .map(
+              ([key, v]) =>
+                `${JSON.stringify(key)}: ${getStringLiteralValue(v)}`
+            )
+            .join(", ")}}`;
+
+      return [new expr.StringLiteral(value), false];
+    }
+
+    return [
+      new expr.StringTemplate([
+        isArray ? new expr.StringLiteral("[") : new expr.StringLiteral("{"),
+        ...converted.flatMap(([key, entry], i) => {
+          const convertedEntry =
+            typeof entry === "string"
+              ? new expr.StringLiteral(JSON.stringify(entry))
+              : convertObjectToStringExpr(entry, isLiteralScope)[0];
+          const maybeComma =
+            i < converted.length - 1 ? [new expr.StringLiteral(", ")] : [];
+          if (isArray) {
+            return [convertedEntry].concat(maybeComma);
+          } else {
+            return [
+              new expr.StringLiteral(JSON.stringify(key) + ": "),
+              convertedEntry,
+            ].concat(maybeComma);
+          }
+        }),
+        isArray ? new expr.StringLiteral("]") : new expr.StringLiteral("}"),
+      ]),
+      true,
+    ];
+  }
+  throw new Error(
+    `Unsupported type '${typeof source}': ${JSON.stringify(source)}`
+  );
+}
+
+function getStringLiteralValue(e: expr.Expr): string {
+  if (e instanceof expr.StringLiteral) {
+    return e.value;
+  } else {
+    throw new Error(`expected a string literal but found: ${e.transpile()}`);
+  }
+}

package/src/selector/SelectorProxy.test.ts

@@ -0,0 +1,172 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Selector, GenericSelector, Path } from ".";
+import { number } from "../schema/number";
+import { string } from "../schema/string";
+import { Source } from "../source";
+import { SourcePath } from "../val";
+import { newSelectorProxy, selectorToVal } from "./SelectorProxy";
+
+describe("SelectorProxy", () => {
+  test("string eq andThen", () => {
+    const sourcePath = "/app/text" as SourcePath;
+    const string1 = newSelectorProxy("foo", sourcePath) as Selector<string>;
+    expectValOrExpr(string1.eq("foo")).toStrictEqual({
+      val: true,
+      [Path]: undefined,
+    });
+    expectValOrExpr(string1.eq("foo").andThen(() => string1)).toStrictEqual({
+      val: "foo",
+      [Path]: sourcePath,
+    });
+  });
+
+  test("array filter eq", () => {
+    const sourcePath = "/app/texts" as SourcePath;
+    const string1 = newSelectorProxy(["foo", "bar"], sourcePath) as Selector<
+      string[]
+    >;
+    expectValOrExpr(
+      string1.map((a) => a).filter((a) => a.eq("foo"))
+    ).toStrictEqual({
+      val: ["foo"],
+      [Path]: "/app/texts",
+    });
+  });
+
+  test("array numbers", () => {
+    const sourcePath = "/app/numbers" as SourcePath;
+    const numbersVal = newSelectorProxy([1, 2, 3], sourcePath) as Selector<
+      string[]
+    >;
+    expectValOrExpr(numbersVal).toStrictEqual({
+      val: [1, 2, 3],
+      [Path]: "/app/numbers",
+    });
+  });
+
+  test("array length", () => {
+    const sourcePath = "/app/numbers" as SourcePath;
+    const numbersVal = newSelectorProxy([1, 2, 3], sourcePath) as Selector<
+      string[]
+    >;
+    expectValOrExpr(numbersVal.length).toStrictEqual({
+      val: 3,
+      [Path]: undefined,
+    });
+  });
+
+  test("array filter match number", () => {
+    const sourcePath = "/app/numbers" as SourcePath;
+    const numbersVal = newSelectorProxy([1, 2, undefined], sourcePath) as
+      | Selector<string[]>
+      | Selector<null[]>;
+    expectValOrExpr(numbersVal.filter(number())).toStrictEqual({
+      val: [1, 2],
+      [Path]: "/app/numbers",
+    });
+  });
+
+  test("array filter match string / undefined / null", () => {
+    const sourcePath = "/app/numbers" as SourcePath;
+    const numbersVal = newSelectorProxy(
+      [1, 2, undefined, null, "test"],
+      sourcePath
+    ) as Selector<(number | string | null)[]>;
+    expectValOrExpr(numbersVal.filter(string().optional())).toStrictEqual({
+      val: [null, null, "test"],
+      [Path]: "/app/numbers",
+    });
+  });
+
+  test("object lookup", () => {
+    const sourcePath = "/app/blog" as SourcePath;
+    const blogsVal = newSelectorProxy(
+      { title: "title1" },
+      sourcePath
+    ) as Selector<{ title: string }>;
+    expectValOrExpr(blogsVal).toStrictEqual({
+      val: { title: "title1" },
+      [Path]: "/app/blog",
+    });
+  });
+
+  test("object prop", () => {
+    const sourcePath = "/app/blog" as SourcePath;
+    const blogsVal = newSelectorProxy(
+      { title: "title1" },
+      sourcePath
+    ) as Selector<{ title: string }>;
+    expectValOrExpr(blogsVal.title).toStrictEqual({
+      val: "title1",
+      [Path]: '/app/blog."title"',
+    });
+  });
+
+  test("array object index", () => {
+    const sourcePath = "/app/blogs" as SourcePath;
+    const blogsVal = newSelectorProxy(
+      [{ title: "title1" }],
+      sourcePath
+    ) as Selector<{ title: string }[]>;
+    expectValOrExpr(blogsVal[0]).toStrictEqual({
+      val: {
+        title: "title1",
+      },
+      [Path]: "/app/blogs.0",
+    });
+  });
+
+  test("array map object index", () => {
+    const sourcePath = "/app/blogs" as SourcePath;
+    const blogsVal = newSelectorProxy(
+      [{ title: "title1" }],
+      sourcePath
+    ) as Selector<{ title: string }[]>;
+    expectValOrExpr(blogsVal.map((v) => v)[0]).toStrictEqual({
+      val: {
+        title: "title1",
+      },
+      [Path]: "/app/blogs.0",
+    });
+  });
+
+  test("map object then index", () => {
+    const sourcePath = "/app/blogs" as SourcePath;
+    const blogsVal = newSelectorProxy(
+      [{ title: "title1" }],
+      sourcePath
+    ) as Selector<{ title: string }[]>;
+    expectValOrExpr(blogsVal.map((blog) => blog)).toStrictEqual({
+      val: [{ title: "title1" }],
+      [Path]: "/app/blogs",
+    });
+  });
+
+  test("map object then index then prop", () => {
+    const sourcePath = "/app/blogs" as SourcePath;
+    const blogsVal = newSelectorProxy(
+      [{ title: "title1" }, { title: "title2" }],
+      sourcePath
+    ) as Selector<{ title: string }[]>;
+    expectValOrExpr(blogsVal.map((blog) => blog)[0].title).toStrictEqual({
+      val: "title1",
+      [Path]: '/app/blogs.0."title"',
+    });
+  });
+
+  test("map object then prop then index", () => {
+    const sourcePath = "/app/blogs" as SourcePath;
+    const blogsVal = newSelectorProxy(
+      [{ title: "title1" }, { title: "title2" }],
+      sourcePath
+    ) as Selector<{ title: string }[]>;
+    expectValOrExpr(blogsVal.map((blog) => blog.title)[0]).toStrictEqual({
+      val: "title1",
+      [Path]: '/app/blogs.0."title"',
+    });
+  });
+});
+
+function expectValOrExpr<T extends Source>(selector: GenericSelector<T>) {
+  return expect(selectorToVal(selector));
+}