@valbuild/core 0.12.0 → 0.13.0

package/src/selector/SelectorProxy.ts

@@ -0,0 +1,237 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Path, GenericSelector, SourceOrExpr, GetSchema } from ".";
+import { Expr } from "../expr/expr";
+import { Schema } from "../schema";
+import { convertImageSource } 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(convertImageSource(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<Source>) {
+                        return f.match(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,
+      };
+  }
+}
+
+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/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/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/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

@@ -0,0 +1,13 @@
+import { SourceArray, SourceObject, SourcePrimitive } from "../source";
+import { Selector as UnknownSelector } from ".";
+import { FileSource } from "../source/file";
+
+declare const brand: unique symbol;
+
+export type I18nSelector<
+  Locales extends readonly string[],
+  T extends SourcePrimitive | SourceObject | SourceArray | FileSource
+> = UnknownSelector<T> & {
+  readonly [brand]: "I18nSelector";
+  all(): { [locale in Locales[number]]: UnknownSelector<T> };
+};

package/src/selector/index.ts

@@ -0,0 +1,159 @@
+/* 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/i18n";
+import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
+import { FileSource } from "../source/file";
+
+/**
+ * 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 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
+  | 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">;
+
+export function getSchema(
+  selector: Selector<Source>
+): Schema<SelectorSource> | undefined {
+  return selector[GetSchema];
+}

package/src/selector/number.ts

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

package/src/selector/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/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

@@ -0,0 +1,9 @@
+import { Selector as UnknownSelector } from ".";
+import { RemoteCompatibleSource } from "../source/remote";
+
+declare const brand: unique symbol;
+
+export type RemoteSelector<T extends RemoteCompatibleSource> =
+  UnknownSelector<T> & {
+    readonly [brand]: "RemoteSelector";
+  };