@valbuild/core 0.12.0 → 0.13.0

package/src/selector/selector.test.ts

@@ -0,0 +1,453 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Selector, GenericSelector, SourceOrExpr, Path } from ".";
+import { string } from "../schema/string";
+import { array } from "../schema/array";
+import { SourcePath } from "../val";
+import { Source } from "../source";
+import { evaluate } from "../expr/eval";
+import * as expr from "../expr/expr";
+import { result } from "../../fp";
+import { object } from "../schema/object";
+import { newSelectorProxy, selectorToVal } from "./SelectorProxy";
+import { newExprSelectorProxy } from "./ExprProxy";
+import { remote, RemoteSource } from "../source/remote";
+
+const modules = {
+  "/app/text": "text1",
+  "/app/texts": ["text1", "text2"] as string[],
+  "/app/blog": { title: "blog1", text: "text1" } as {
+    title: string | null;
+    text: string;
+  },
+  "/app/blogs": [
+    { title: "blog1", text: "text1" },
+    { title: undefined, text: "text2" },
+  ] as { title: string | null; text: string }[],
+  "/app/empty": "",
+  "/app/large/nested": BFV(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const remoteModules: {
+  [key in keyof TestModules]: RemoteSource<TestModules[key]>;
+} = {
+  "/app/text": remote("/app/text"),
+  "/app/texts": remote("/app/texts"),
+  "/app/blog": remote("/app/blog"),
+  "/app/blogs": remote("/app/blogs"),
+  "/app/empty": remote("/app/empty"),
+  "/app/large/nested": remote("/app/large/nested"),
+};
+
+const SelectorModuleTestCases: {
+  description: string;
+  input: (remote: boolean) => GenericSelector<Source>;
+  expected: Expected;
+}[] = [
+  {
+    description: "string module lookup",
+    input: (remote) => testModule("/app/text", remote),
+    expected: {
+      val: "text1",
+      [Path]: "/app/text",
+    },
+  },
+  {
+    description: "basic eq",
+    input: (remote) => testModule("/app/text", remote).eq("text1"),
+    expected: {
+      val: true,
+      [Path]: undefined,
+    },
+  },
+  {
+    description: "andThen noop",
+    input: (remote) => testModule("/app/text", remote).andThen((v) => v),
+    expected: {
+      val: "text1",
+      [Path]: "/app/text",
+    },
+  },
+  {
+    description: "array module lookup",
+    input: (remote) => testModule("/app/texts", remote),
+    expected: {
+      val: ["text1", "text2"],
+      [Path]: "/app/texts",
+    },
+  },
+  {
+    description: "string andThen eq",
+    input: (remote) =>
+      testModule("/app/text", remote).andThen((v) => v.eq("text1")),
+    expected: {
+      val: true,
+      [Path]: undefined,
+    },
+  },
+  {
+    description: "empty string andThen eq",
+    input: (remote) =>
+      testModule("/app/empty", remote).andThen((v) => v.eq("text1")),
+    expected: {
+      val: "",
+      [Path]: "/app/empty",
+    },
+  },
+  {
+    description: "andThen literal eq",
+    input: (remote) =>
+      testModule("/app/text", remote)
+        .andThen(() => "foo")
+        .eq("foo"),
+    expected: {
+      val: true,
+      [Path]: undefined,
+    },
+  },
+  {
+    description: "andThen undefined literal eq",
+    input: (remote) =>
+      testModule("/app/text", remote)
+        .andThen(() => undefined)
+        .eq("foo"),
+    expected: {
+      val: false,
+      [Path]: undefined,
+    },
+  },
+  {
+    description: "empty andThen literal eq",
+    input: (remote) =>
+      testModule("/app/empty", remote)
+        .andThen(() => "foo")
+        .eq("foo"),
+    expected: {
+      val: false,
+      [Path]: undefined,
+    },
+  },
+  {
+    description: "string andThen array literal and index",
+    input: (remote) =>
+      testModule("/app/text", remote).andThen((v) => [v, "text2"])[0],
+    expected: { val: "text1", [Path]: "/app/text" },
+  },
+  {
+    description: "string map undefined -> null literal conversion",
+    input: (remote) =>
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      testModule("/app/blogs", remote).map((v) => ({ title: undefined })),
+    expected: {
+      val: [{ title: null }, { title: null }],
+      [Path]: "/app/blogs",
+    },
+  },
+  {
+    description: "array map noop",
+    input: (remote) => testModule("/app/texts", remote).map((v) => v),
+    expected: { val: ["text1", "text2"], [Path]: "/app/texts" },
+  },
+  {
+    description: "array map projection with undefined",
+    input: (remote) =>
+      testModule("/app/blogs", remote).map((v) => ({
+        otherTitle: v.title,
+        other: undefined,
+      })),
+    expected: {
+      val: [
+        { otherTitle: "blog1", other: null },
+        { otherTitle: null, other: null },
+      ],
+      [Path]: "/app/blogs",
+    },
+  },
+  {
+    description: "array index with eq",
+    input: (remote) => testModule("/app/texts", remote)[0].eq("text1"),
+    expected: { val: true, [Path]: undefined },
+  },
+  {
+    description: "object module lookup",
+    input: (remote) => testModule("/app/blog", remote),
+    expected: { val: { text: "text1", title: "blog1" }, [Path]: "/app/blog" },
+  },
+  {
+    description: "object andThen property lookup",
+    input: (remote) => testModule("/app/blog", remote).andThen((v) => v.title),
+    expected: { val: "blog1", [Path]: '/app/blog."title"' },
+  },
+  {
+    description: "array object manipulation: basic indexed obj",
+    input: (remote) =>
+      testModule("/app/blogs", remote)
+        .map((v) => v)[0]
+        .title.eq("blog1"),
+    expected: {
+      val: true,
+      [Path]: undefined,
+    },
+  },
+  {
+    description: "array object manipulation: filter",
+    input: (remote) =>
+      testModule("/app/blogs", remote).filter((v) => v.title.eq("blog1")),
+    expected: {
+      val: [{ text: "text1", title: "blog1" }],
+      [Path]: "/app/blogs",
+    },
+  },
+  {
+    description: "array object manipulation: map with tuple literal",
+    input: (remote) =>
+      testModule("/app/blogs", remote).map((a) => [1, a.title]),
+    expected: {
+      val: [
+        [1, "blog1"],
+        [1, null],
+      ],
+      [Path]: "/app/blogs",
+    },
+  },
+  // TODO: tuple literal was reverted
+  // {
+  //   description: "array object manipulation: map with tuple literal",
+  //   input: (remote) =>
+  //     testModule("/app/blogs", remote).map((a) => [1, a])[0][1].title,
+  //   expected: {
+  //     val: "blog1",
+  //     [Path]: "/app/blogs.0.title",
+  //   },
+  // },
+  {
+    description: "array object manipulation: with literals",
+    input: (remote) =>
+      testModule("/app/blogs", remote)
+        .map((v) => ({
+          title: {
+            foo: "string",
+          },
+          subTitle: { bar: v.title },
+        }))[0]
+        .title.foo.eq("string"),
+    expected: { val: true, [Path]: undefined },
+  },
+  {
+    description: "array object manipulation: with literals",
+    input: (remote) =>
+      testModule("/app/blogs", remote)
+        .map((v) => [v.title, v.title])[0][0]
+        .eq("blog1"),
+    expected: { val: true, [Path]: undefined },
+  },
+  {
+    description: "array object manipulation: with large nested objects",
+    input: (remote) =>
+      testModule("/app/large/nested", remote).map((v) => ({
+        title: {
+          foo: "string",
+        },
+        subTitle: { bar: v },
+      }))[0].subTitle.bar.that.even.more.even[0].more.even.more.even.more,
+    expected: {
+      val: "that.even.more.even.more",
+      [Path]:
+        '/app/large/nested.0."that"."even"."more"."even".0."more"."even"."more"."even"."more"',
+    },
+  },
+];
+
+const RemoteAndLocaleSelectorModuleTestCases = SelectorModuleTestCases.flatMap(
+  (testCase) => [
+    {
+      input: () => testCase.input(false),
+      description: `local ${testCase.description}`,
+      expected: testCase.expected,
+      remote: false,
+    },
+    {
+      input: () => testCase.input(true),
+      description: `remote ${testCase.description}`,
+      expected: testCase.expected,
+      remote: true,
+    },
+  ]
+);
+
+describe("selector", () => {
+  test.each(RemoteAndLocaleSelectorModuleTestCases)(
+    "$description",
+    ({ input, expected, remote }) => {
+      if (input instanceof Error) {
+        throw input;
+      }
+      // TODO: ideally we should be able to evaluate remote and local
+      if (!remote) {
+        const localeRes = input();
+        expect(selectorToVal(localeRes)).toStrictEqual(expected);
+      } else {
+        const res = evaluate(
+          // @ts-expect-error TODO: fix this
+          input()[SourceOrExpr],
+          (ref) =>
+            newSelectorProxy(
+              modules[ref as keyof typeof modules],
+              ref as SourcePath
+            ),
+          []
+        );
+        if (result.isErr(res)) {
+          throw res.error;
+        }
+        expect(selectorToVal(res.value)).toStrictEqual(
+          // NOTE: all expected values for REMOTE should be changed to return Vals
+          expected
+        );
+      }
+    }
+  );
+});
+
+type TestModules = typeof modules;
+
+type Expected = any; // TODO: should be Val | Expr
+
+function testModule<P extends keyof TestModules>(
+  sourcePath: P,
+  remote: boolean
+): Selector<TestModules[P]> {
+  try {
+    if (remote) {
+      return newExprSelectorProxy(
+        root(sourcePath as SourcePath)
+      ) as unknown as Selector<TestModules[P]>;
+    }
+    return newSelectorProxy(modules[sourcePath], sourcePath as SourcePath);
+  } catch (e) {
+    // avoid failing all test suite failure on test case creation, instead returns error and throws it inside the test
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return e as any;
+  }
+}
+
+/** A big schema */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function BFS() {
+  return array(
+    object({
+      title: object({
+        foo: object({
+          inner: array(
+            object({
+              innerInnerTitle: object({
+                even: object({
+                  more: string(),
+                }),
+              }),
+            })
+          ),
+        }),
+      }),
+      bar: string(),
+      many: array(string()),
+      props: string(),
+      are: string(),
+      here: object({
+        even: object({
+          more: string(),
+        }),
+      }),
+      for: string(),
+      testing: string(),
+      purposes: string(),
+      and: string(),
+      to: string(),
+      make: string(),
+      sure: string(),
+      that: object({
+        even: object({
+          more: object({
+            even: array(
+              object({
+                more: object({
+                  even: object({
+                    more: object({
+                      even: object({
+                        more: string(),
+                      }),
+                    }),
+                  }),
+                }),
+              })
+            ),
+          }),
+        }),
+      }),
+      the: string(),
+      type: string(),
+      system: string(),
+      works: string(),
+      as: string(),
+      expected: string(),
+    })
+  );
+}
+
+/** A big value */
+function BFV() {
+  return [
+    {
+      title: {
+        foo: {
+          inner: [
+            {
+              innerInnerTitle: {
+                even: { more: "inner.innerInnerTitle.even.more" },
+              },
+            },
+          ],
+        },
+      },
+      bar: "bar",
+      many: ["many1", "many2", "many3"],
+      props: "props",
+      are: "are",
+      here: { even: { more: "here.even.more" } },
+      for: "for",
+      testing: "testing",
+      purposes: "purposes",
+      and: "and",
+      to: "to",
+      make: "make",
+      sure: "sure",
+      that: {
+        even: {
+          more: {
+            even: [
+              {
+                more: {
+                  even: {
+                    more: { even: { more: "that.even.more.even.more" } },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+      the: "the",
+      type: "type",
+      system: "system",
+      works: "works",
+      as: "as",
+      expected: "expected",
+    },
+  ];
+}
+
+function root(sourcePath: string) {
+  return new expr.Call(
+    [new expr.Sym("val"), new expr.StringLiteral(sourcePath)],
+    false
+  );
+}

package/src/selector/selectorOf.ts

@@ -0,0 +1,7 @@
+import { Selector } from ".";
+import { newSelectorProxy } from "./SelectorProxy";
+import { Source } from "../source";
+
+export function selectorOf<T extends Source>(t: T): Selector<T> {
+  return newSelectorProxy(t);
+}

package/src/selector/string.ts

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

package/src/source/file.ts

@@ -0,0 +1,45 @@
+import { VAL_EXTENSION } from ".";
+import { JsonPrimitive } from "../Json";
+
+export const FILE_REF_PROP = "_ref" as const;
+
+/**
+ * A file source represents the path to a (local) file.
+ *
+ * It will be resolved into a Asset object.
+ *
+ */
+export type FileSource<
+  Metadata extends { readonly [key: string]: JsonPrimitive } | undefined =
+    | { readonly [key: string]: JsonPrimitive }
+    | undefined
+> = {
+  readonly [FILE_REF_PROP]: string;
+  readonly [VAL_EXTENSION]: "file";
+  readonly metadata?: Metadata;
+};
+
+export function file<
+  Metadata extends { readonly [key: string]: JsonPrimitive }
+>(ref: string, metadata: Metadata): FileSource<Metadata>;
+export function file(ref: string, metadata?: undefined): FileSource<undefined>;
+export function file<
+  Metadata extends { readonly [key: string]: JsonPrimitive } | undefined
+>(ref: string, metadata?: Metadata): FileSource<Metadata> {
+  return {
+    [FILE_REF_PROP]: ref,
+    [VAL_EXTENSION]: "file",
+    metadata,
+  } as FileSource<Metadata>;
+}
+
+export function isFile(obj: unknown): obj is FileSource {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    VAL_EXTENSION in obj &&
+    obj[VAL_EXTENSION] === "file" &&
+    FILE_REF_PROP in obj &&
+    typeof obj[FILE_REF_PROP] === "string"
+  );
+}

package/src/source/i18n.ts

@@ -0,0 +1,60 @@
+import { F } from "ts-toolbelt";
+import { SourcePrimitive, VAL_EXTENSION } from ".";
+import { FileSource } from "./file";
+
+/**
+ * I18n sources cannot have nested remote sources.
+ */
+export type I18nCompatibleSource =
+  | SourcePrimitive
+  | I18nObject
+  | I18nArray
+  | FileSource;
+export type I18nObject = { [key in string]: I18nCompatibleSource };
+export type I18nArray = readonly I18nCompatibleSource[];
+
+/**
+ * An i18n source is a map of locales to sources.
+ *
+ * Its selector will default to the underlying source. It is possible to call `.all` on i18n sources, which returns an object with all the locales
+ *
+ */
+export type I18nSource<
+  Locales extends readonly string[],
+  T extends I18nCompatibleSource
+> = {
+  readonly [locale in Locales[number]]: T;
+} & {
+  readonly [VAL_EXTENSION]: "i18n";
+};
+
+export type I18n<Locales extends readonly string[]> = <
+  Src extends I18nCompatibleSource
+>(source: {
+  [locale in Locales[number]]: Src;
+}) => I18nSource<Locales, Src>;
+export function i18n<Locales extends readonly string[]>(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  locales: F.Narrow<Locales>
+): <Src extends I18nCompatibleSource>(source: {
+  [locale in Locales[number]]: Src;
+}) => I18nSource<Locales, Src> {
+  return (source) => {
+    return {
+      ...source,
+      [VAL_EXTENSION]: "i18n",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as I18nSource<Locales, any>;
+  };
+}
+
+export function isI18n(
+  obj: unknown
+): obj is I18nSource<string[], I18nCompatibleSource> {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    VAL_EXTENSION in obj &&
+    obj[VAL_EXTENSION] === "i18n"
+  );
+}

package/src/source/index.ts

@@ -0,0 +1,50 @@
+import { FileSource } from "./file";
+import { I18nSource, I18nCompatibleSource } from "./i18n";
+import { RemoteSource, RemoteCompatibleSource } from "./remote";
+
+export type Source =
+  | SourcePrimitive
+  | SourceObject
+  | SourceArray
+  | I18nSource<string[], I18nCompatibleSource>
+  | RemoteSource<RemoteCompatibleSource>
+  | FileSource;
+
+export type SourceObject = { [key in string]: Source } & {
+  // TODO: update these restricted parameters:
+  fold?: never;
+  andThen?: never;
+  _ref?: never;
+  _type?: never;
+  val?: never;
+  valPath?: never; // used when serializing vals
+};
+export type SourceArray = readonly Source[];
+export type SourcePrimitive = string | number | boolean | null;
+
+/* Branded extension types: file, remote, i18n  */
+export const VAL_EXTENSION = "_type" as const;
+
+export function getValExtension(source: Source) {
+  return (
+    source &&
+    typeof source === "object" &&
+    VAL_EXTENSION in source &&
+    source[VAL_EXTENSION]
+  );
+}
+
+/**
+ * A phantom type parameter is one that doesn't show up at runtime, but is checked statically (and only) at compile time.
+ *
+ * An example where this is useful is remote types, where the type of the remote source is known at compile time,
+ * but the value is not there before it is fetched.
+ *
+ * @example
+ * type Example<T> = string & PhantomType<T>;
+ *
+ **/
+declare const PhantomType: unique symbol;
+export type PhantomType<T> = {
+  [PhantomType]: T;
+};

package/src/source/remote.ts

@@ -0,0 +1,54 @@
+import { SourcePrimitive, VAL_EXTENSION, PhantomType } from ".";
+import { RichText } from "../schema/richtext";
+import { FileSource } from "./file";
+import { I18nCompatibleSource, I18nSource } from "./i18n";
+
+/**
+ * Remote sources cannot include other remote sources.
+ */
+export type RemoteCompatibleSource =
+  | SourcePrimitive
+  | RemoteObject
+  | RemoteArray
+  | RichText
+  | FileSource
+  | I18nSource<string[], I18nCompatibleSource>;
+export type RemoteObject = { [key in string]: RemoteCompatibleSource };
+export type RemoteArray = readonly RemoteCompatibleSource[];
+
+export const REMOTE_REF_PROP = "_ref" as const; // TODO: same as FILE_REF_PROP so use same prop?
+
+declare const brand: unique symbol;
+export type RemoteRef = string & { readonly [brand]: "RemoteRef" };
+
+/**
+ * A remote source is a hash that represents a remote object.
+ *
+ * It will be resolved into a ValRemote object.
+ */
+export type RemoteSource<Src extends RemoteCompatibleSource> = {
+  readonly [REMOTE_REF_PROP]: RemoteRef;
+  readonly [VAL_EXTENSION]: "remote";
+} & PhantomType<Src>;
+
+export function remote<Src extends RemoteCompatibleSource>(
+  ref: string
+): RemoteSource<Src> {
+  return {
+    [REMOTE_REF_PROP]: ref as RemoteRef,
+    [VAL_EXTENSION]: "remote",
+  } as RemoteSource<Src>;
+}
+
+export function isRemote(
+  obj: unknown
+): obj is RemoteSource<RemoteCompatibleSource> {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    VAL_EXTENSION in obj &&
+    obj[VAL_EXTENSION] === "remote" &&
+    REMOTE_REF_PROP in obj &&
+    typeof obj[REMOTE_REF_PROP] === "string"
+  );
+}

package/src/val/array.ts

@@ -0,0 +1,10 @@
+import { SourcePath, Val as UnknownVal } from ".";
+import { JsonArray } from "../Json";
+import { Path } from "../selector";
+
+export type Val<T extends JsonArray> = {
+  readonly [key in keyof T]: UnknownVal<T[key]>;
+} & {
+  readonly [Path]: SourcePath | undefined;
+  readonly val: T;
+};