@valbuild/core 0.14.0 → 0.16.0

package/src/schema/index.ts

@@ -1,3 +1,4 @@
+import { Json } from "../Json";
 import { SelectorSource } from "../selector";
 import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
 import { SourcePath } from "../val";
@@ -12,6 +13,7 @@ import { SerializedOneOfSchema } from "./oneOf";
 import { SerializedRichTextSchema } from "./richtext";
 import { SerializedStringSchema } from "./string";
 import { SerializedUnionSchema } from "./union";
+import { ValidationErrors } from "./validation/ValidationError";
 
 export type SerializedSchema =
   | SerializedStringSchema
@@ -27,8 +29,8 @@ export type SerializedSchema =
   | SerializedI18nSchema;
 
 export abstract class Schema<Src extends SelectorSource> {
-  abstract validate(src: Src): false | Record<SourcePath, string[]>;
-  abstract match(src: Src): boolean; // TODO: false | Record<SourcePath, string[]>;
+  abstract validate(path: SourcePath, src: Src): ValidationErrors;
+  abstract assert(src: Src): boolean; // TODO: false | Record<SourcePath, string[]>;
   abstract optional(): Schema<Src | null>;
   abstract serialize(): SerializedSchema;
   remote(): Src extends RemoteCompatibleSource
@@ -37,6 +39,25 @@ export abstract class Schema<Src extends SelectorSource> {
     // TODO: Schema<never, "Cannot create remote schema from non-remote source.">
     throw new Error("You need Val Ultra to use .remote()");
   }
+
+  /** MUTATES! since internal and perf sensitive */
+  protected appendValidationError(
+    current: ValidationErrors,
+    path: SourcePath,
+    message: string,
+    value?: unknown
+  ): ValidationErrors {
+    if (current) {
+      if (current[path]) {
+        current[path].push({ message, value });
+      } else {
+        current[path] = [{ message, value }];
+      }
+      return current;
+    } else {
+      return { [path]: [{ message, value }] } as ValidationErrors;
+    }
+  }
 }
 
 export type SchemaTypeOf<T extends Schema<SelectorSource>> = T extends Schema<

package/src/schema/literal.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Schema, SerializedSchema } from ".";
 import { SourcePath } from "../val";
+import { ValidationErrors } from "./validation/ValidationError";
 
 export type SerializedLiteralSchema = {
   type: "literal";
@@ -13,11 +14,31 @@ export class LiteralSchema<Src extends string | null> extends Schema<Src> {
     super();
   }
 
-  validate(src: Src): false | Record<SourcePath, string[]> {
-    throw new Error("Method not implemented.");
+  validate(path: SourcePath, src: Src): ValidationErrors {
+    if (this.opt && (src === null || src === undefined)) {
+      return false;
+    }
+    if (typeof src !== "string") {
+      return {
+        [path]: [
+          { message: `Expected 'string', got '${typeof src}'`, value: src },
+        ],
+      } as ValidationErrors;
+    }
+    if (src !== this.value) {
+      return {
+        [path]: [
+          {
+            message: `Expected literal '${this.value}', got '${src}'`,
+            value: src,
+          },
+        ],
+      } as ValidationErrors;
+    }
+    return false;
   }
 
-  match(src: Src): boolean {
+  assert(src: Src): boolean {
     if (this.opt && (src === null || src === undefined)) {
       return true;
     }

package/src/schema/number.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Schema, SerializedSchema } from ".";
 import { SourcePath } from "../val";
+import { ValidationErrors } from "./validation/ValidationError";
 
 type NumberOptions = {
   max?: number;
@@ -17,11 +18,21 @@ export class NumberSchema<Src extends number | null> extends Schema<Src> {
   constructor(readonly options?: NumberOptions, readonly opt: boolean = false) {
     super();
   }
-  validate(src: Src): false | Record<SourcePath, string[]> {
-    throw new Error("Method not implemented.");
+  validate(path: SourcePath, src: Src): ValidationErrors {
+    if (this.opt && (src === null || src === undefined)) {
+      return false;
+    }
+    if (typeof src !== "number") {
+      return {
+        [path]: [
+          { message: `Expected 'number', got '${typeof src}'`, value: src },
+        ],
+      } as ValidationErrors;
+    }
+    return false;
   }
 
-  match(src: Src): boolean {
+  assert(src: Src): boolean {
     if (this.opt && (src === null || src === undefined)) {
       return true;
     }

package/src/schema/object.ts

@@ -1,7 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Schema, SchemaTypeOf, SerializedSchema } from ".";
 import { SelectorSource } from "../selector";
+import { createValPathOfItem } from "../selector/SelectorProxy";
 import { SourcePath } from "../val";
+import { ValidationErrors } from "./validation/ValidationError";
 
 export type SerializedObjectSchema = {
   type: "object";
@@ -21,13 +23,51 @@ export class ObjectSchema<Props extends ObjectSchemaProps> extends Schema<
     super();
   }
 
-  validate(
-    src: ObjectSchemaSrcOf<Props>
-  ): false | Record<SourcePath, string[]> {
-    throw new Error("Method not implemented.");
+  validate(path: SourcePath, src: ObjectSchemaSrcOf<Props>): ValidationErrors {
+    let error: ValidationErrors = false;
+
+    if (this.opt && (src === null || src === undefined)) {
+      return false;
+    }
+
+    if (typeof src !== "object") {
+      return {
+        [path]: [{ message: `Expected 'object', got '${typeof src}'` }],
+      } as ValidationErrors;
+    } else if (Array.isArray(src)) {
+      return {
+        [path]: [{ message: `Expected 'object', got 'array'` }],
+      } as ValidationErrors;
+    }
+
+    Object.entries(this.items).forEach(([key, schema]) => {
+      const subPath = createValPathOfItem(path, key);
+      if (!subPath) {
+        error = this.appendValidationError(
+          error,
+          path,
+          `Internal error: could not create path at ${
+            !path && typeof path === "string" ? "<empty string>" : path
+          } at key ${key}`, // Should! never happen
+          src
+        );
+      } else {
+        const subError = schema.validate(subPath, src[key]);
+        if (subError && error) {
+          error = {
+            ...subError,
+            ...error,
+          };
+        } else if (subError) {
+          error = subError;
+        }
+      }
+    });
+
+    return error;
   }
 
-  match(src: ObjectSchemaSrcOf<Props>): boolean {
+  assert(src: ObjectSchemaSrcOf<Props>): boolean {
     if (this.opt && (src === null || src === undefined)) {
       return true;
     }
@@ -35,8 +75,11 @@ export class ObjectSchema<Props extends ObjectSchemaProps> extends Schema<
       return false;
     }
 
-    // TODO: checks all props
-
+    for (const [key, schema] of Object.entries(this.items)) {
+      if (!schema.assert(src[key])) {
+        return false;
+      }
+    }
     return typeof src === "object" && !Array.isArray(src);
   }
 

package/src/schema/oneOf.ts

@@ -4,6 +4,7 @@ import { ValModuleBrand } from "../module";
 import { GenericSelector } from "../selector";
 import { Source, SourceArray } from "../source";
 import { getValPath, SourcePath } from "../val";
+import { ValidationErrors } from "./validation/ValidationError";
 
 export type SerializedOneOfSchema = {
   type: "oneOf";
@@ -26,10 +27,10 @@ export class OneOfSchema<
   constructor(readonly selector: Sel, readonly opt: boolean = false) {
     super();
   }
-  validate(src: OneOfSelector<Sel>): false | Record<SourcePath, string[]> {
+  validate(path: SourcePath, src: OneOfSelector<Sel>): ValidationErrors {
     throw new Error("Method not implemented.");
   }
-  match(src: OneOfSelector<Sel>): boolean {
+  assert(src: OneOfSelector<Sel>): boolean {
     throw new Error("Method not implemented.");
   }
   optional(): Schema<OneOfSelector<Sel> | null> {

package/src/schema/richtext.ts

@@ -1,7 +1,12 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Schema, SerializedSchema } from ".";
+import { VAL_EXTENSION } from "../source";
 import { RichTextSource } from "../source/richtext";
 import { SourcePath } from "../val";
+import {
+  ValidationError,
+  ValidationErrors,
+} from "./validation/ValidationError";
 
 export type SerializedRichTextSchema = {
   type: "richtext";
@@ -11,10 +16,65 @@ export type SerializedRichTextSchema = {
 export class RichTextSchema<
   Src extends RichTextSource | null
 > extends Schema<Src> {
-  validate(src: Src): false | Record<SourcePath, string[]> {
-    throw new Error("Method not implemented.");
+  validate(path: SourcePath, src: Src): ValidationErrors {
+    if (this.opt && (src === null || src === undefined)) {
+      return false;
+    }
+    if (src === null || src === undefined) {
+      return {
+        [path]: [
+          { message: `Expected non-nullable got '${src}'` } as ValidationError,
+        ],
+      } as ValidationErrors;
+    }
+
+    if (typeof src !== "object" && !Array.isArray(src)) {
+      return {
+        [path]: [
+          {
+            message: `Expected 'object' (that is not of an array) or 'string', got '${typeof src}'`,
+            value: src,
+          } as ValidationError,
+        ],
+      } as ValidationErrors;
+    }
+
+    if (src[VAL_EXTENSION] !== "richtext") {
+      return {
+        [path]: [
+          {
+            message: `Expected _type key with value 'richtext' got '${src[VAL_EXTENSION]}'`,
+            value: src,
+          } as ValidationError,
+        ],
+      } as ValidationErrors;
+    }
+
+    if (src.type !== "root") {
+      return {
+        [path]: [
+          {
+            message: `Expected type key with value 'root' got '${src.type}'`,
+            value: src,
+          } as ValidationError,
+        ],
+      } as ValidationErrors;
+    }
+
+    if (typeof src.children !== "object" && !Array.isArray(src.children)) {
+      return {
+        [path]: [
+          {
+            message: `Expected children to be an array, but got '${src.type}'`,
+            value: src,
+          } as ValidationError,
+        ],
+      } as ValidationErrors;
+    }
+
+    return false;
   }
-  match(src: Src): boolean {
+  assert(src: Src): boolean {
     // TODO:
     return true;
   }

package/src/schema/string.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Schema, SerializedSchema } from ".";
 import { SourcePath } from "../val";
+import { ValidationErrors } from "./validation/ValidationError";
 
 type StringOptions = {
   maxLength?: number;
@@ -18,11 +19,21 @@ export class StringSchema<Src extends string | null> extends Schema<Src> {
     super();
   }
 
-  validate(src: Src): false | Record<SourcePath, string[]> {
-    throw new Error("Method not implemented.");
+  validate(path: SourcePath, src: Src): ValidationErrors {
+    if (this.opt && (src === null || src === undefined)) {
+      return false;
+    }
+    if (typeof src !== "string") {
+      return {
+        [path]: [
+          { message: `Expected 'string', got '${typeof src}'`, value: src },
+        ],
+      } as ValidationErrors;
+    }
+    return false;
   }
 
-  match(src: Src): boolean {
+  assert(src: Src): boolean {
     if (this.opt && (src === null || src === undefined)) {
       return true;
     }

package/src/schema/union.ts

@@ -3,6 +3,7 @@ import { Schema, SerializedSchema } from ".";
 import { SelectorSource } from "../selector";
 import { SourceObject } from "../source";
 import { SourcePath } from "../val";
+import { ValidationErrors } from "./validation/ValidationError";
 
 export type SerializedUnionSchema = {
   type: "union";
@@ -24,10 +25,10 @@ export class UnionSchema<
   Key extends string,
   T extends Schema<SourceObject & { [k in Key]: string }>[]
 > extends Schema<SourceOf<Key, T>> {
-  validate(src: SourceOf<Key, T>): false | Record<SourcePath, string[]> {
+  validate(path: SourcePath, src: SourceOf<Key, T>): ValidationErrors {
     throw new Error("Method not implemented.");
   }
-  match(src: SourceOf<Key, T>): boolean {
+  assert(src: SourceOf<Key, T>): boolean {
     throw new Error("Method not implemented.");
   }
   optional(): Schema<SourceOf<Key, T> | null> {

package/src/schema/validation/ValidationError.ts

@@ -0,0 +1,16 @@
+import { SourcePath } from "../../val";
+import { ValidationFix } from "./ValidationFix";
+
+export type ValidationError = {
+  message: string;
+  value?: unknown;
+  fixes?: ValidationFix[];
+};
+
+/**
+ * Equals `false` if no validation errors were found.
+ * Errors are indexed by the full source path.
+ *
+ * Global errors have the path `"/"`.
+ */
+export type ValidationErrors = false | Record<SourcePath, ValidationError[]>;

package/src/schema/validation/ValidationFix.ts

@@ -0,0 +1,6 @@
+export const ValidationFix = [
+  "image:add-metadata",
+  "image:replace-metadata",
+] as const;
+
+export type ValidationFix = (typeof ValidationFix)[number];

package/src/schema/validation.test.ts

@@ -0,0 +1,226 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { createValPathOfItem } from "../selector/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";
+
+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: "basic object(string)",
+  //   input: { one: "one val", two: 1 },
+  //   schema: object({
+  //     one: string(),
+  //     two: string(),
+  //   }),
+  //   expected: [pathOf("two")],
+  // },
+  // 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: add metadata",
+  //   input: fileVal("test", {
+  //     width: 100,
+  //     height: 100,
+  //     sha256: "test",
+  //   }),
+  //   schema: image(),
+  //   expected: [testPath],
+  //   fixes: {
+  //     [testPath]: ["image:add-metadata"],
+  //   },
+  // },
+  // {
+  //   description: "failure image: check metadata",
+  //   input: fileVal("test", {
+  //     width: 100,
+  //     height: 100,
+  //     sha256:
+  //       "9e420dc93157ab98338542ba6f1d34fcf829d646aa729a86720fa3f4cb2d0076",
+  //   }),
+  //   schema: image(),
+  //   expected: [testPath],
+  //   fixes: {
+  //     [testPath]: ["image:check-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);
+      console.log(JSON.stringify({ result, expected }, null, 2));
+      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

@@ -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));
                       }