@valbuild/core 0.15.0 → 0.17.0

package/src/schema/validation.test.ts

@@ -0,0 +1,291 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { createValPathOfItem } from "../selector/future/SelectorProxy";
+import { SourcePath } from "../val";
+import { array } from "./array";
+import { boolean } from "./boolean";
+import { literal } from "./literal";
+import { number } from "./number";
+import { object } from "./object";
+import { string } from "./string";
+import { file as fileVal } from "../source/file";
+import { richtext as richtextVal } from "../source/richtext";
+import { image } from "./image";
+import { ValidationFix } from "./validation/ValidationFix";
+import {
+  ValidationError,
+  ValidationErrors,
+} from "./validation/ValidationError";
+import { richtext } from "./richtext";
+import { record } from "./record";
+import { keyOf } from "./keyOf";
+import { content } from "../module";
+
+const testPath = "/test" as SourcePath;
+const pathOf = (p: string | symbol | number) => {
+  return createValPathOfItem(testPath, p);
+};
+const ValidationTestCases: {
+  description: string;
+  input: any;
+  schema: any;
+  expected: [SourcePath | undefined] | false;
+  fixes?: {
+    [path: string]: ValidationFix[];
+  };
+}[] = [
+  // boolean
+  {
+    description: "basic boolean (true)",
+    input: true,
+    schema: boolean(),
+    expected: false,
+  },
+  {
+    description: "basic boolean (false)",
+    input: false,
+    schema: boolean(),
+    expected: false,
+  },
+  {
+    description: "failing boolean (null)",
+    input: null,
+    schema: boolean(),
+    expected: [testPath],
+  },
+  {
+    description: "optional boolean (null)",
+    input: null,
+    schema: boolean().optional(),
+    expected: false,
+  },
+  {
+    description: "failing boolean",
+    input: "false",
+    schema: boolean(),
+    expected: [testPath],
+  },
+  // number
+  {
+    description: "basic number (0)",
+    input: 0,
+    schema: number(),
+    expected: false,
+  },
+  {
+    description: "basic number (-1)",
+    input: -1,
+    schema: number(),
+    expected: false,
+  },
+  {
+    description: "basic number (1)",
+    input: 1,
+    schema: number(),
+    expected: false,
+  },
+  {
+    description: "basic number (1)",
+    input: 1,
+    schema: number(),
+    expected: false,
+  },
+  // string
+  {
+    description: "basic string",
+    input: "two",
+    schema: string(),
+    expected: false,
+  },
+  {
+    description: "failing string",
+    input: 1,
+    schema: string(),
+    expected: [testPath],
+  },
+  // literal
+  {
+    description: "basic literal",
+    input: "one",
+    schema: literal("one"),
+    expected: false,
+  },
+  {
+    description: "failing literal",
+    input: "two",
+    schema: literal("one"),
+    expected: [testPath],
+  },
+  // array
+  {
+    description: "basic array(string)",
+    input: ["one", "two"],
+    schema: array(string()),
+    expected: false,
+  },
+  {
+    description: "failing array(string)",
+    input: [true, "false"],
+    schema: array(string()),
+    expected: [pathOf(0)],
+  },
+  // object
+  {
+    description: "basic object(string)",
+    input: { one: "one val", two: 2 },
+    schema: object({
+      one: string(),
+      two: number(),
+    }),
+    expected: false,
+  },
+  {
+    description: "failing object(string)",
+    input: { one: "one val", two: 1 },
+    schema: object({
+      one: string(),
+      two: string(),
+    }),
+    expected: [pathOf("two")],
+  },
+  // record
+  {
+    description: "basic record(string)",
+    input: { one: "one val", two: "two val" },
+    schema: record(string()),
+    expected: false,
+  },
+  {
+    description: "failing record(string)",
+    input: { one: "one val", two: 1 },
+    schema: object({
+      one: string(),
+      two: string(),
+    }),
+    expected: [pathOf("two")],
+  },
+  // keyof
+  {
+    description: "basic keyOf(array)",
+    input: 1,
+    schema: keyOf(content("/keyof-module", array(string()), [])),
+    expected: false,
+  },
+  {
+    description: "failing keyOf(record)",
+    input: "1",
+    schema: keyOf(content("/keyof-module", array(string()), [])),
+    expected: [testPath],
+  },
+  {
+    description: "basic keyOf(record)",
+    input: "one",
+    schema: keyOf(content("/keyof-module", record(string()), {})),
+    expected: false,
+  },
+  {
+    description: "failing keyOf(record)",
+    input: 1,
+    schema: keyOf(content("/keyof-module", record(string()), {})),
+    expected: [testPath],
+  },
+  {
+    description: "basic keyOf(object)",
+    input: "test1",
+    schema: keyOf(
+      content("/keyof-module", object({ test1: string(), test2: string() }), {
+        test1: "",
+        test2: "",
+      })
+    ),
+    expected: false,
+  },
+  {
+    description: "failing keyOf(object)",
+    input: "test",
+    schema: keyOf(
+      content("/keyof-module", object({ test1: string(), test2: string() }), {
+        test1: "",
+        test2: "",
+      })
+    ),
+    expected: [testPath],
+  },
+  // image / file
+  {
+    description: "optional image",
+    input: null,
+    schema: image().optional(),
+    expected: false,
+  },
+  {
+    description: "failure image:: null",
+    input: null,
+    schema: image(),
+    expected: [testPath],
+  },
+  {
+    description: "failure image: replace metadata",
+    input: fileVal("test", {
+      width: 100,
+      height: 100,
+      sha256: "test",
+    }),
+    schema: image(),
+    expected: [testPath],
+    fixes: {
+      [testPath]: ["image:replace-metadata"],
+    },
+  },
+  {
+    description: "failure image: check metadata",
+    input: fileVal("test", {
+      width: 100,
+      height: 100,
+      sha256:
+        "9e420dc93157ab98338542ba6f1d34fcf829d646aa729a86720fa3f4cb2d0076",
+    }),
+    schema: image(),
+    expected: [testPath],
+    fixes: {
+      [testPath]: ["image:replace-metadata"],
+    },
+  },
+  // richtext
+  {
+    description: "basic richtext",
+    input: richtextVal("test"),
+    expected: false,
+    schema: richtext(),
+  },
+  // TODO: more richtext cases
+  // TODO: union
+  // TODO: oneOf
+  // TODO: i18n
+];
+
+describe("validation", () => {
+  test.each(ValidationTestCases)(
+    'validate ($description): "$expected"',
+    ({ input, schema, expected, fixes }) => {
+      const result = schema.validate(testPath, input);
+      if (result) {
+        expect(Object.keys(result)).toStrictEqual(expected);
+        if (fixes) {
+          expect(
+            Object.fromEntries(
+              Object.entries(result as ValidationErrors).map(
+                ([path, errors]) => [
+                  path,
+                  errors.flatMap((error: ValidationError) => error.fixes),
+                ]
+              )
+            )
+          ).toStrictEqual(fixes);
+        }
+      } else {
+        expect(result).toStrictEqual(expected);
+      }
+    }
+  );
+});

package/src/selector/SelectorProxy.ts

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Path, GenericSelector, SourceOrExpr, GetSchema } from ".";
+import { Path, GenericSelector, GetSource, GetSchema } from "./index";
 import { Expr } from "../expr/expr";
 import { Schema } from "../schema";
-import { convertImageSource } from "../schema/image";
+import { convertFileSource } from "../schema/image";
 import { Source, SourcePrimitive, VAL_EXTENSION } from "../source";
 import { FILE_REF_PROP } from "../source/file";
 import { isSerializedVal, SourcePath } from "../val";
@@ -22,7 +22,7 @@ export function isSelector(source: any): source is GenericSelector<Source> {
   return (
     typeof source === "object" &&
     source !== null &&
-    (SourceOrExpr in source || Path in source)
+    (GetSource in source || Path in source)
   );
 }
 
@@ -44,7 +44,7 @@ export function newSelectorProxy(
     if (typeof fileRef !== "string") {
       throw Error("Invalid file ref: " + fileRef);
     }
-    return newSelectorProxy(convertImageSource(source), path, moduleSchema);
+    return newSelectorProxy(convertFileSource(source), path, moduleSchema);
   }
 
   switch (typeof source) {
@@ -57,7 +57,7 @@ export function newSelectorProxy(
         return new Proxy(source, {
           // TODO: see proxy docs if we want more traps
           has(target, prop: string | symbol) {
-            if (prop === SourceOrExpr) {
+            if (prop === GetSource) {
               return true;
             }
             if (prop === Path) {
@@ -72,7 +72,7 @@ export function newSelectorProxy(
             return prop in target;
           },
           get(target, prop: string | symbol) {
-            if (prop === SourceOrExpr) {
+            if (prop === GetSource) {
               return source;
             }
             if (prop === Path) {
@@ -97,7 +97,7 @@ export function newSelectorProxy(
                     )
                     .filter((a) => {
                       if (f && f instanceof Schema) {
-                        return f.match(unValify(a));
+                        return f.assert(unValify(a));
                       } else {
                         return unValify(f(a));
                       }
@@ -154,7 +154,7 @@ export function newSelectorProxy(
         eq: (other: SourcePrimitive | GenericSelector<Source>) => {
           let otherValue: any = other;
           if (isSelector(other)) {
-            otherValue = other[SourceOrExpr];
+            otherValue = other[GetSource];
             if (otherValue instanceof Expr) {
               throw Error("TODO: Cannot evaluate equality with an Expr");
             }
@@ -164,7 +164,7 @@ export function newSelectorProxy(
         andThen: (f: any) => {
           return andThen(f, source === undefined ? null : source, path);
         },
-        [SourceOrExpr]: source === undefined ? null : source,
+        [GetSource]: source === undefined ? null : source,
         [Path]: path,
         [GetSchema]: moduleSchema,
       };
@@ -178,7 +178,7 @@ function selectorAsVal(sel: any): any {
   } else if (
     typeof sel === "object" &&
     sel &&
-    !(SourceOrExpr in sel) &&
+    !(GetSource in sel) &&
     !Array.isArray(sel)
   ) {
     // is object
@@ -188,7 +188,7 @@ function selectorAsVal(sel: any): any {
   } else if (
     typeof sel === "object" &&
     sel &&
-    !(SourceOrExpr in sel) &&
+    !(GetSource in sel) &&
     Array.isArray(sel)
   ) {
     // is array
@@ -196,9 +196,9 @@ function selectorAsVal(sel: any): any {
   } else if (
     typeof sel === "object" &&
     sel &&
-    (SourceOrExpr in sel || Path in sel)
+    (GetSource in sel || Path in sel)
   ) {
-    return selectorAsVal(sel?.[SourceOrExpr]);
+    return selectorAsVal(sel?.[GetSource]);
   } else if (sel === undefined) {
     return null;
   }
@@ -218,7 +218,7 @@ export function createValPathOfItem(
 }
 
 export function selectorToVal(s: any): any {
-  const v = selectorAsVal(s?.[SourceOrExpr]);
+  const v = selectorAsVal(s?.[GetSource]);
   return {
     val: v,
     [Path]: s?.[Path],
@@ -229,9 +229,9 @@ export function selectorToVal(s: any): any {
 function unValify(valueOrSelector: any) {
   if (
     typeof valueOrSelector === "object" &&
-    (SourceOrExpr in valueOrSelector || Path in valueOrSelector)
+    (GetSource in valueOrSelector || Path in valueOrSelector)
   ) {
-    const selectorValue = valueOrSelector[SourceOrExpr];
+    const selectorValue = valueOrSelector[GetSource];
     return selectorValue;
   }
   return valueOrSelector;

package/src/selector/array.ts

@@ -1,13 +1,5 @@
-import {
-  Selector as UnknownSelector,
-  GenericSelector,
-  SelectorOf,
-  SelectorSource,
-} from ".";
-import { Schema } from "../schema";
+import { GenericSelector } from ".";
 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
@@ -18,20 +10,4 @@ export type UndistributedSourceArray<T extends SourceArray> = [T] extends [
   : 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>;
-};
+export type Selector<T extends SourceArray> = GenericSelector<T>;

package/src/selector/file.ts

@@ -1,14 +1,6 @@
-import {
-  Selector as UnknownSelector,
-  GenericSelector,
-  SelectorOf,
-  SelectorSource,
-} from ".";
+import { Selector as UnknownSelector, GenericSelector } from "./index";
 
 // 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/{ExprProxy.test.ts → future/ExprProxy.test.ts}

@@ -1,8 +1,8 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { convertLiteralProxy, newExprSelectorProxy } from "./ExprProxy";
-import * as expr from "../expr/expr";
+import * as expr from "../../expr/expr";
 import { GenericSelector, SelectorSource, SourceOrExpr } from ".";
-import { Source } from "../source";
+import { Source } from "../../source";
 
 const ExprSelectorTestCases: any[] = [
   {

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

@@ -1,6 +1,6 @@
 import { Selector, SelectorSource, SourceOrExpr } from ".";
-import * as expr from "../expr/expr";
-import { Source, SourcePrimitive } from "../source";
+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;
@@ -25,6 +25,13 @@ export function newExprSelectorProxy<T extends Source>(
   }) 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) {

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

@@ -1,9 +1,9 @@
 /* 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 { number } from "../../schema/number";
+import { string } from "../../schema/string";
+import { Source } from "../../source";
+import { SourcePath } from "../../val";
 import { newSelectorProxy, selectorToVal } from "./SelectorProxy";
 
 describe("SelectorProxy", () => {