@valbuild/core 0.26.0 → 0.27.0

package/src/selector/SelectorProxy.ts

@@ -1,238 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Path, GenericSelector, GetSource, GetSchema } from "./index";
-import { Expr } from "../expr/expr";
-import { Schema } from "../schema";
-import { convertFileSource } from "../schema/image";
-import { Source, SourcePrimitive, VAL_EXTENSION } from "../source";
-import { FILE_REF_PROP } from "../source/file";
-import { isSerializedVal, SourcePath } from "../val";
-
-function hasOwn<T extends PropertyKey>(obj: object, prop: T): boolean {
-  return Object.prototype.hasOwnProperty.call(obj, prop);
-}
-
-function andThen(f: (...args: any[]) => any, source: any, path?: SourcePath) {
-  if (source) {
-    return newSelectorProxy(f(newSelectorProxy(source, path)));
-  }
-  return newSelectorProxy(source, path);
-}
-
-export function isSelector(source: any): source is GenericSelector<Source> {
-  return (
-    typeof source === "object" &&
-    source !== null &&
-    (GetSource in source || Path in source)
-  );
-}
-
-export function newSelectorProxy(
-  source: any,
-  path?: SourcePath,
-  moduleSchema?: any
-): any {
-  if (typeof source === "object") {
-    if (isSelector(source)) {
-      return source;
-    } else if (isSerializedVal(source)) {
-      return newSelectorProxy(source.val, source.valPath);
-    }
-  }
-
-  if (source && source[FILE_REF_PROP] && source[VAL_EXTENSION] === "file") {
-    const fileRef = source[FILE_REF_PROP];
-    if (typeof fileRef !== "string") {
-      throw Error("Invalid file ref: " + fileRef);
-    }
-    return newSelectorProxy(convertFileSource(source), path, moduleSchema);
-  }
-
-  switch (typeof source) {
-    case "function":
-    case "symbol":
-      throw Error(`Invalid selector type: ${typeof source}: ${source}`);
-    case "object":
-      // Handles both objects and arrays!
-      if (source !== null) {
-        return new Proxy(source, {
-          // TODO: see proxy docs if we want more traps
-          has(target, prop: string | symbol) {
-            if (prop === GetSource) {
-              return true;
-            }
-            if (prop === Path) {
-              return true;
-            }
-            if (prop === "andThen") {
-              return true;
-            }
-            if (prop === GetSchema) {
-              return true;
-            }
-            return prop in target;
-          },
-          get(target, prop: string | symbol) {
-            if (prop === GetSource) {
-              return source;
-            }
-            if (prop === Path) {
-              return path;
-            }
-            if (prop === GetSchema) {
-              return moduleSchema;
-            }
-            if (prop === "andThen") {
-              return (f: any) => andThen(f, source, path);
-            }
-            if (Array.isArray(target)) {
-              if (prop === "filter") {
-                return (f: any) => {
-                  const filtered = target
-                    .map((a, i) =>
-                      newSelectorProxy(
-                        a,
-                        createValPathOfItem(path, i),
-                        moduleSchema?.item
-                      )
-                    )
-                    .filter((a) => {
-                      if (f && f instanceof Schema) {
-                        return f.assert(unValify(a));
-                      } else {
-                        return unValify(f(a));
-                      }
-                    });
-                  return newSelectorProxy(filtered, path, moduleSchema);
-                };
-              } else if (prop === "map") {
-                return (f: any) => {
-                  const filtered = target.map((a, i) => {
-                    const valueOrSelector = f(
-                      newSelectorProxy(
-                        a,
-                        createValPathOfItem(path, i),
-                        moduleSchema?.item
-                      ),
-                      newSelectorProxy(i)
-                    );
-                    if (isSelector(valueOrSelector)) {
-                      return valueOrSelector;
-                    }
-                    return newSelectorProxy(valueOrSelector);
-                  });
-                  return newSelectorProxy(filtered, path, moduleSchema);
-                };
-              }
-            }
-            if (Array.isArray(target) && prop === "length") {
-              return newSelectorProxy(target.length);
-            }
-            const reflectedValue = Reflect.get(target, prop);
-
-            if (hasOwn(source, prop)) {
-              if (!Number.isNaN(Number(prop))) {
-                return newSelectorProxy(
-                  reflectedValue,
-                  createValPathOfItem(path, Number(prop)),
-                  moduleSchema?.item
-                );
-              }
-              return newSelectorProxy(
-                reflectedValue,
-                createValPathOfItem(path, prop),
-                moduleSchema?.items[prop]
-              );
-            }
-            return reflectedValue;
-          },
-        });
-      }
-    // intentional fallthrough
-    // eslint-disable-next-line no-fallthrough
-    default:
-      return {
-        eq: (other: SourcePrimitive | GenericSelector<Source>) => {
-          let otherValue: any = other;
-          if (isSelector(other)) {
-            otherValue = other[GetSource];
-            if (otherValue instanceof Expr) {
-              throw Error("TODO: Cannot evaluate equality with an Expr");
-            }
-          }
-          return newSelectorProxy(source === otherValue, undefined);
-        },
-        andThen: (f: any) => {
-          return andThen(f, source === undefined ? null : source, path);
-        },
-        [GetSource]: source === undefined ? null : source,
-        [Path]: path,
-        [GetSchema]: moduleSchema,
-      };
-  }
-}
-
-function selectorAsVal(sel: any): any {
-  if (isSerializedVal(sel)) {
-    // is a serialized val
-    return selectorAsVal(newSelectorProxy(sel.val, sel.valPath));
-  } else if (
-    typeof sel === "object" &&
-    sel &&
-    !(GetSource in sel) &&
-    !Array.isArray(sel)
-  ) {
-    // is object
-    return Object.fromEntries(
-      Object.entries(sel).map(([k, v]) => [k, selectorAsVal(v)])
-    );
-  } else if (
-    typeof sel === "object" &&
-    sel &&
-    !(GetSource in sel) &&
-    Array.isArray(sel)
-  ) {
-    // is array
-    return sel.map((v) => selectorAsVal(v));
-  } else if (
-    typeof sel === "object" &&
-    sel &&
-    (GetSource in sel || Path in sel)
-  ) {
-    return selectorAsVal(sel?.[GetSource]);
-  } else if (sel === undefined) {
-    return null;
-  }
-  return sel;
-}
-
-export function createValPathOfItem(
-  arrayPath: SourcePath | undefined,
-  prop: string | number | symbol
-) {
-  if (typeof prop === "symbol") {
-    throw Error(
-      `Cannot create val path of array item with symbol prop: ${prop.toString()}`
-    );
-  }
-  return arrayPath && (`${arrayPath}.${JSON.stringify(prop)}` as SourcePath);
-}
-
-export function selectorToVal(s: any): any {
-  const v = selectorAsVal(s?.[GetSource]);
-  return {
-    val: v,
-    [Path]: s?.[Path],
-  };
-}
-
-// TODO: could we do .val on the objects instead?
-function unValify(valueOrSelector: any) {
-  if (
-    typeof valueOrSelector === "object" &&
-    (GetSource in valueOrSelector || Path in valueOrSelector)
-  ) {
-    const selectorValue = valueOrSelector[GetSource];
-    return selectorValue;
-  }
-  return valueOrSelector;
-}

package/src/selector/array.ts

@@ -1,13 +0,0 @@
-import { GenericSelector } from ".";
-import { Source, SourceArray } from "../source";
-
-export type UndistributedSourceArray<T extends SourceArray> = [T] extends [
-  infer U // infer here to avoid Type instantiation is excessively deep and possibly infinite. See: https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437. Avoiding infer extends to keep us below TS 4.9 compat
-]
-  ? U extends Source[]
-    ? Selector<U>
-    : never
-  : never;
-
-// TODO: docs
-export type Selector<T extends SourceArray> = GenericSelector<T>;

package/src/selector/boolean.ts

@@ -1,4 +0,0 @@
-import { Selector as PrimitiveSelector } from "./primitive";
-
-// TODO: docs
-export type Selector<T extends boolean> = PrimitiveSelector<T>;

package/src/selector/file.ts

@@ -1,6 +0,0 @@
-import { Selector as UnknownSelector, GenericSelector } from "./index";
-
-// TODO: docs
-export type FileSelector = GenericSelector<{ url: string }> & {
-  readonly url: UnknownSelector<string>;
-};

package/src/selector/future/ExprProxy.test.ts

@@ -1,203 +0,0 @@
-/* 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/future/ExprProxy.ts

@@ -1,216 +0,0 @@
-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>;
-}
-
-export function root(sourcePath: string) {
-  return new expr.Call(
-    [new expr.Sym("val"), new expr.StringLiteral(sourcePath)],
-    false
-  );
-}
-
-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()}`);
-  }
-}