@valbuild/core 0.15.0 → 0.17.0

package/src/selector/future/SelectorProxy.ts

@@ -0,0 +1,238 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Path, GenericSelector, SourceOrExpr, GetSchema } from ".";
+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 &&
+    (SourceOrExpr 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 === SourceOrExpr) {
+              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 === SourceOrExpr) {
+              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[SourceOrExpr];
+            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);
+        },
+        [SourceOrExpr]: 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 &&
+    !(SourceOrExpr 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 &&
+    !(SourceOrExpr in sel) &&
+    Array.isArray(sel)
+  ) {
+    // is array
+    return sel.map((v) => selectorAsVal(v));
+  } else if (
+    typeof sel === "object" &&
+    sel &&
+    (SourceOrExpr in sel || Path in sel)
+  ) {
+    return selectorAsVal(sel?.[SourceOrExpr]);
+  } 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?.[SourceOrExpr]);
+  return {
+    val: v,
+    [Path]: s?.[Path],
+  };
+}
+
+// TODO: could we do .val on the objects instead?
+function unValify(valueOrSelector: any) {
+  if (
+    typeof valueOrSelector === "object" &&
+    (SourceOrExpr in valueOrSelector || Path in valueOrSelector)
+  ) {
+    const selectorValue = valueOrSelector[SourceOrExpr];
+    return selectorValue;
+  }
+  return valueOrSelector;
+}

package/src/selector/future/array.ts

@@ -0,0 +1,37 @@
+import {
+  Selector as UnknownSelector,
+  GenericSelector,
+  SelectorOf,
+  SelectorSource,
+} from ".";
+import { Schema } from "../../schema";
+import { Source, SourceArray } from "../../source";
+import { Selector as BooleanSelector } from "./boolean";
+import { Selector as NumberSelector } from "./number";
+
+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> & {
+  readonly [key: number]: UnknownSelector<T[number]>;
+} & {
+  length: NumberSelector<number>;
+  filter(
+    predicate: (
+      v: UnknownSelector<T[number]>
+    ) => BooleanSelector<boolean> | boolean
+  ): Selector<T>;
+  filter<U extends Source>(schema: Schema<U>): Selector<U[]>;
+  map<U extends SelectorSource>(
+    f: (v: UnknownSelector<T[number]>, i: UnknownSelector<number>) => U
+  ): SelectorOf<U[]>; // TODO: this should be SelectorOf<ArraySelectorSourceBranded<U[]>>;
+  andThen<U extends SelectorSource>(
+    f: (v: UnknownSelector<NonNullable<T>>) => U
+  ): SelectorOf<U | T>;
+};

package/src/selector/future/boolean.ts

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

package/src/selector/future/file.ts

@@ -0,0 +1,14 @@
+import {
+  Selector as UnknownSelector,
+  GenericSelector,
+  SelectorOf,
+  SelectorSource,
+} from ".";
+
+// TODO: docs
+export type FileSelector = GenericSelector<{ url: string }> & {
+  readonly url: UnknownSelector<string>;
+  andThen<U extends SelectorSource>(
+    f: (v: UnknownSelector<NonNullable<{ url: string }>>) => U
+  ): SelectorOf<U> | UnknownSelector<boolean>;
+};

package/src/selector/{i18n.ts → future/i18n.ts}

@@ -1,6 +1,6 @@
-import { SourceArray, SourceObject, SourcePrimitive } from "../source";
+import { SourceArray, SourceObject, SourcePrimitive } from "../../source";
 import { Selector as UnknownSelector } from ".";
-import { FileSource } from "../source/file";
+import { FileSource } from "../../source/file";
 
 declare const brand: unique symbol;
 

package/src/selector/future/index.ts

@@ -0,0 +1,165 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { I18nSelector } from "./i18n";
+import { Selector as ObjectSelector } from "./object";
+import { UndistributedSourceArray as ArraySelector } from "./array";
+import { Selector as NumberSelector } from "./number";
+import { Selector as StringSelector } from "./string";
+import { Selector as BooleanSelector } from "./boolean";
+import { Selector as PrimitiveSelector } from "./primitive";
+import { FileSelector } from "./file";
+import { SourcePath } from "../../val";
+import {
+  Source,
+  SourceArray,
+  SourceObject,
+  SourcePrimitive,
+} from "../../source";
+import { Schema } from "../../schema";
+import { Expr } from "../../expr/expr";
+import { RemoteSelector } from "./remote";
+import { A } from "ts-toolbelt";
+import { I18nSource, I18nCompatibleSource } from "../../source/future/i18n";
+import {
+  RemoteCompatibleSource,
+  RemoteSource,
+} from "../../source/future/remote";
+import { FileSource } from "../../source/file";
+import { RichText, RichTextSource } from "../../source/richtext";
+
+/**
+ * Selectors can be used to select parts of a Val module.
+ * Unlike queries, joins, aggregates etc is and will not be supported.
+ *
+ * They are designed to be be used as if they were "normal" JSON data,
+ * though some concessions had to be made because of TypeScript limitations.
+ *
+ * Selectors works equally on source content, defined in code, and remote content.
+ *
+ * @example
+ * // Select the title of a document
+ * const titles = useVal(docsVal.map((doc) => doc.title));
+ *
+ * @example
+ * // Match on a union type
+ * const titles = useVal(docsVal.map((doc) => doc.fold("type")({
+ *   newsletter: (newsletter) => newsletter.title,
+ *   email: (email) => email.subject,
+ * }));
+ *
+ */
+export type Selector<T extends Source> = Source extends T
+  ? GenericSelector<T>
+  : T extends I18nSource<infer L, infer S>
+  ? I18nSelector<L, S>
+  : T extends RemoteSource<infer S>
+  ? S extends RemoteCompatibleSource
+    ? RemoteSelector<S>
+    : GenericSelector<Source, "Could not determine remote source">
+  : T extends FileSource
+  ? FileSelector
+  : T extends RichTextSource
+  ? RichText
+  : T extends SourceObject
+  ? ObjectSelector<T>
+  : T extends SourceArray
+  ? ArraySelector<T>
+  : T extends string
+  ? StringSelector<T>
+  : T extends number
+  ? NumberSelector<T>
+  : T extends boolean
+  ? BooleanSelector<T>
+  : T extends null
+  ? PrimitiveSelector<null>
+  : never;
+
+export type SelectorSource =
+  | SourcePrimitive
+  | undefined
+  | readonly SelectorSource[]
+  | {
+      [key: string]: SelectorSource;
+    }
+  | I18nSource<readonly string[], I18nCompatibleSource>
+  | RemoteSource<RemoteCompatibleSource>
+  | FileSource
+  | RichTextSource
+  | GenericSelector<Source>;
+
+/**
+ * @internal
+ */
+export const GetSchema = Symbol("GetSchema");
+/**
+/**
+ * @internal
+ */
+export const Path = Symbol("Path");
+/**
+ * @internal
+ */
+export const SourceOrExpr = Symbol("SourceOrExpr");
+/**
+ * @internal
+ */
+export const ValError = Symbol("ValError");
+export abstract class GenericSelector<
+  out T extends Source,
+  Error extends string | undefined = undefined
+> {
+  readonly [Path]: SourcePath | undefined;
+  readonly [SourceOrExpr]: T | Expr;
+  readonly [ValError]: Error | undefined;
+  readonly [GetSchema]: Schema<T> | undefined;
+  constructor(
+    valOrExpr: T,
+    path: SourcePath | undefined,
+    schema?: Schema<T>,
+    error?: Error
+  ) {
+    this[Path] = path;
+    this[SourceOrExpr] = valOrExpr;
+    this[ValError] = error;
+    this[GetSchema] = schema;
+  }
+
+  assert<U extends Source, E extends Source = null>(
+    schema: Schema<U>,
+    other?: () => E
+  ): SelectorOf<U | E> {
+    throw new Error("Not implemented");
+  }
+}
+
+export type SourceOf<T extends SelectorSource> = Source extends T
+  ? Source
+  : T extends Source
+  ? T
+  : T extends undefined
+  ? null
+  : T extends GenericSelector<infer S>
+  ? S
+  : T extends readonly (infer S)[] // NOTE: the infer S instead of Selector Source here, is to avoid infinite recursion
+  ? S extends SelectorSource
+    ? {
+        [key in keyof T]: SourceOf<A.Try<T[key], SelectorSource>>;
+      }
+    : never
+  : T extends { [key: string]: SelectorSource }
+  ? {
+      [key in keyof T]: SourceOf<A.Try<T[key], SelectorSource>>;
+    }
+  : never;
+
+/**
+ * Use this type to convert types that accepts both Source and Selectors
+ *
+ * An example would be where literals are supported like in most higher order functions (e.g. map in array)
+ **/
+export type SelectorOf<U extends SelectorSource> = Source extends U
+  ? GenericSelector<Source>
+  : SourceOf<U> extends infer S // we need this to avoid infinite recursion
+  ? S extends Source
+    ? Selector<S>
+    : GenericSelector<Source, "Could not determine selector of source">
+  : GenericSelector<Source, "Could not determine source">;

package/src/selector/future/number.ts

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

package/src/selector/future/object.ts

@@ -0,0 +1,22 @@
+import {
+  Selector as UnknownSelector,
+  GenericSelector,
+  SelectorOf,
+  SelectorSource,
+} from ".";
+import { SourceObject } from "../../source";
+
+// TODO: docs
+export type Selector<T extends SourceObject> = GenericSelector<T> & {
+  fold<Tag extends string>(
+    key: Tag
+  ): <U extends SelectorSource>(cases: {
+    [key in T[Tag & keyof T] & string]: (v: UnknownSelector<T>) => U;
+  }) => SelectorOf<U>;
+
+  andThen<U extends SelectorSource>(
+    f: (v: UnknownSelector<NonNullable<T>>) => U
+  ): SelectorOf<U>;
+} & {
+  readonly [key in keyof T]: UnknownSelector<T[key]>;
+};

package/src/selector/future/primitive.ts

@@ -0,0 +1,17 @@
+import {
+  Selector as UnknownSelector,
+  GenericSelector,
+  SelectorOf,
+  SelectorSource,
+} from ".";
+import { Source, SourcePrimitive } from "../../source";
+import { Selector as BooleanSelector } from "./boolean";
+
+export type Selector<T extends SourcePrimitive> = GenericSelector<T> & {
+  eq(other: Source): BooleanSelector<boolean>;
+  andThen<U extends SelectorSource>(
+    f: (v: UnknownSelector<NonNullable<T>>) => U
+  ): SelectorOf<U | NullableOf<T>>;
+};
+
+type NullableOf<T extends Source> = T extends null ? null : never;

package/src/selector/{remote.ts → future/remote.ts}

@@ -1,5 +1,5 @@
 import { Selector as UnknownSelector } from ".";
-import { RemoteCompatibleSource } from "../source/remote";
+import { RemoteCompatibleSource } from "../../source/future/remote";
 
 declare const brand: unique symbol;
 

package/src/selector/{selector.test.ts → future/selector.test.ts}

@@ -1,16 +1,14 @@
 /* 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 { string } from "../../schema/string";
+import { array } from "../../schema/array";
+import { SourcePath } from "../../val";
+import { Source } from "../../source";
+import { evaluate } from "../../expr/eval";
+import { result } from "../../fp";
+import { object } from "../../schema/object";
 import { newSelectorProxy, selectorToVal } from "./SelectorProxy";
-import { newExprSelectorProxy } from "./ExprProxy";
-import { remote, RemoteSource } from "../source/remote";
+import { newExprSelectorProxy, root } from "./ExprProxy";
 
 const modules = {
   "/app/text": "text1",
@@ -26,17 +24,6 @@ const modules = {
   "/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;
@@ -440,10 +427,3 @@ function BFV() {
     },
   ];
 }
-
-function root(sourcePath: string) {
-  return new expr.Call(
-    [new expr.Sym("val"), new expr.StringLiteral(sourcePath)],
-    false
-  );
-}

package/src/selector/{selectorOf.ts → future/selectorOf.ts}

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

package/src/selector/future/string.ts

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

package/src/selector/index.ts

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { I18nSelector } from "./i18n";
 import { Selector as ObjectSelector } from "./object";
 import { UndistributedSourceArray as ArraySelector } from "./array";
 import { Selector as NumberSelector } from "./number";
@@ -10,43 +8,12 @@ import { FileSelector } from "./file";
 import { SourcePath } from "../val";
 import { Source, SourceArray, SourceObject, SourcePrimitive } from "../source";
 import { Schema } from "../schema";
-import { Expr } from "../expr/expr";
-import { RemoteSelector } from "./remote";
-import { A } from "ts-toolbelt";
-import { I18nSource, I18nCompatibleSource } from "../source/i18n";
-import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
+import type { A } from "ts-toolbelt";
 import { FileSource } from "../source/file";
 import { RichText, RichTextSource } from "../source/richtext";
 
-/**
- * Selectors can be used to select parts of a Val module.
- * Unlike queries, joins, aggregates etc is and will not be supported.
- *
- * They are designed to be be used as if they were "normal" JSON data,
- * though some concessions had to be made because of TypeScript limitations.
- *
- * Selectors works equally on source content, defined in code, and remote content.
- *
- * @example
- * // Select the title of a document
- * const titles = useVal(docsVal.map((doc) => doc.title));
- *
- * @example
- * // Match on a union type
- * const titles = useVal(docsVal.map((doc) => doc.fold("type")({
- *   newsletter: (newsletter) => newsletter.title,
- *   email: (email) => email.subject,
- * }));
- *
- */
 export type Selector<T extends Source> = Source extends T
   ? GenericSelector<T>
-  : T extends I18nSource<infer L, infer S>
-  ? I18nSelector<L, S>
-  : T extends RemoteSource<infer S>
-  ? S extends RemoteCompatibleSource
-    ? RemoteSelector<S>
-    : GenericSelector<Source, "Could not determine remote source">
   : T extends FileSource
   ? FileSelector
   : T extends RichTextSource
@@ -72,8 +39,6 @@ export type SelectorSource =
   | {
       [key: string]: SelectorSource;
     }
-  | I18nSource<readonly string[], I18nCompatibleSource>
-  | RemoteSource<RemoteCompatibleSource>
   | FileSource
   | RichTextSource
   | GenericSelector<Source>;
@@ -90,7 +55,7 @@ export const Path = Symbol("Path");
 /**
  * @internal
  */
-export const SourceOrExpr = Symbol("SourceOrExpr");
+export const GetSource = Symbol("GetSource");
 /**
  * @internal
  */
@@ -100,7 +65,7 @@ export abstract class GenericSelector<
   Error extends string | undefined = undefined
 > {
   readonly [Path]: SourcePath | undefined;
-  readonly [SourceOrExpr]: T | Expr;
+  readonly [GetSource]: T;
   readonly [ValError]: Error | undefined;
   readonly [GetSchema]: Schema<T> | undefined;
   constructor(
@@ -110,17 +75,10 @@ export abstract class GenericSelector<
     error?: Error
   ) {
     this[Path] = path;
-    this[SourceOrExpr] = valOrExpr;
+    this[GetSource] = valOrExpr;
     this[ValError] = error;
     this[GetSchema] = schema;
   }
-
-  assert<U extends Source, E extends Source = null>(
-    schema: Schema<U>,
-    other?: () => E
-  ): SelectorOf<U | E> {
-    throw new Error("Not implemented");
-  }
 }
 
 export type SourceOf<T extends SelectorSource> = Source extends T