@valbuild/core 0.15.0 → 0.17.0

package/src/schema/keyOf.ts

@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema, SourceObject } from "..";
+import { ValModuleBrand } from "../module";
+import { GenericSelector, GetSchema } from "../selector";
+import { SourceArray } from "../source";
+import { SourcePath, getValPath } from "../val";
+import { ValidationErrors } from "./validation/ValidationError";
+
+export type SerializedKeyOfSchema = {
+  type: "keyOf";
+  selector: SourcePath;
+  opt: boolean;
+};
+
+type KeyOfSelector<Sel extends GenericSelector<SourceArray | SourceObject>> =
+  Sel extends GenericSelector<infer S>
+    ? // TODO: remove any:
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      S extends readonly any[]
+      ? number
+      : S extends SourceObject
+      ? keyof S
+      : // TODO: remove any:
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      S extends Record<string, any>
+      ? string
+      : never
+    : never;
+
+export class KeyOfSchema<
+  Sel extends GenericSelector<SourceArray | SourceObject>
+> extends Schema<KeyOfSelector<Sel>> {
+  constructor(readonly selector: Sel, readonly opt: boolean = false) {
+    super();
+  }
+  validate(path: SourcePath, src: KeyOfSelector<Sel>): ValidationErrors {
+    if (this.opt && (src === null || src === undefined)) {
+      return false;
+    }
+    const schema = this.selector[GetSchema];
+    if (!schema) {
+      return {
+        [path]: [
+          {
+            message: `Schema not found for module. keyOf must be used with a Val Module`,
+          },
+        ],
+      };
+    }
+    const serializedSchema = schema.serialize();
+
+    if (
+      !(
+        serializedSchema.type === "array" ||
+        serializedSchema.type === "object" ||
+        serializedSchema.type === "record"
+      )
+    ) {
+      return {
+        [path]: [
+          {
+            message: `Schema in keyOf must be an 'array', 'object' or 'record'. Found '${serializedSchema.type}'`,
+          },
+        ],
+      };
+    }
+    if (serializedSchema.opt && (src === null || src === undefined)) {
+      return false;
+    }
+    if (serializedSchema.type === "array" && typeof src !== "number") {
+      return {
+        [path]: [
+          {
+            message: "Type of value in keyof (array) must be 'number'",
+          },
+        ],
+      };
+    }
+    if (serializedSchema.type === "record" && typeof src !== "string") {
+      return {
+        [path]: [
+          {
+            message: "Type of value in keyof (record) must be 'string'",
+          },
+        ],
+      };
+    }
+    if (serializedSchema.type === "object") {
+      const keys = Object.keys(serializedSchema.items);
+      if (!keys.includes(src as string)) {
+        return {
+          [path]: [
+            {
+              message: `Value of keyOf (object) must be: ${keys.join(
+                ", "
+              )}. Found: ${src}`,
+            },
+          ],
+        };
+      }
+    }
+    return false;
+  }
+
+  assert(src: KeyOfSelector<Sel>): boolean {
+    if (this.opt && (src === null || src === undefined)) {
+      return true;
+    }
+    const schema = this.selector[GetSchema];
+    if (!schema) {
+      return false;
+    }
+    const serializedSchema = schema.serialize();
+
+    if (
+      !(
+        serializedSchema.type === "array" ||
+        serializedSchema.type === "object" ||
+        serializedSchema.type === "record"
+      )
+    ) {
+      return false;
+    }
+    if (serializedSchema.opt && (src === null || src === undefined)) {
+      return true;
+    }
+    if (serializedSchema.type === "array" && typeof src !== "number") {
+      return false;
+    }
+    if (serializedSchema.type === "record" && typeof src !== "string") {
+      return false;
+    }
+    if (serializedSchema.type === "object") {
+      const keys = Object.keys(serializedSchema.items);
+      if (!keys.includes(src as string)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  optional(): Schema<KeyOfSelector<Sel> | null> {
+    return new KeyOfSchema(this.selector, true);
+  }
+
+  serialize(): SerializedSchema {
+    const path = getValPath(this.selector);
+    if (!path) {
+      throw new Error(
+        "Cannot serialize oneOf schema with empty selector. keyOf must be used with a Val Module."
+      );
+    }
+    return {
+      type: "keyOf",
+      selector: path,
+      opt: this.opt,
+    };
+  }
+}
+
+export const keyOf = <
+  Src extends GenericSelector<SourceArray | SourceObject> & ValModuleBrand // ValModuleBrand enforces call site to pass in a val module - selectors are not allowed. The reason is that this should make it easier to patch. We might be able to relax this constraint in the future
+>(
+  valModule: Src
+): Schema<KeyOfSelector<Src>> => {
+  return new KeyOfSchema(valModule);
+};

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/record.ts

@@ -0,0 +1,103 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SchemaTypeOf, SerializedSchema } from ".";
+import { initVal } from "../initVal";
+import { SelectorSource } from "../selector";
+import { createValPathOfItem } from "../selector/SelectorProxy";
+import { SourcePath } from "../val";
+import { string } from "./string";
+import { ValidationErrors } from "./validation/ValidationError";
+
+export type SerializedRecordSchema = {
+  type: "record";
+  item: SerializedSchema;
+  opt: boolean;
+};
+
+export class RecordSchema<T extends Schema<SelectorSource>> extends Schema<
+  Record<string, SchemaTypeOf<T>>
+> {
+  constructor(readonly item: T, readonly opt: boolean = false) {
+    super();
+  }
+
+  validate(
+    path: SourcePath,
+    src: Record<string, SchemaTypeOf<T>>
+  ): 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;
+    }
+    if (Array.isArray(src)) {
+      return {
+        [path]: [{ message: `Expected 'object', got 'array'` }],
+      } as ValidationErrors;
+    }
+    Object.entries(src).forEach(([key, elem]) => {
+      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 ${elem}`, // Should! never happen
+          src
+        );
+      } else {
+        const subError = this.item.validate(subPath, elem as SelectorSource);
+        if (subError && error) {
+          error = {
+            ...subError,
+            ...error,
+          };
+        } else if (subError) {
+          error = subError;
+        }
+      }
+    });
+
+    return error;
+  }
+
+  assert(src: Record<string, SchemaTypeOf<T>>): boolean {
+    if (this.opt && (src === null || src === undefined)) {
+      return true;
+    }
+    if (!src) {
+      return false;
+    }
+
+    for (const [, item] of Object.entries(src)) {
+      if (!this.item.assert(item)) {
+        return false;
+      }
+    }
+    return typeof src === "object" && !Array.isArray(src);
+  }
+
+  optional(): Schema<Record<string, SchemaTypeOf<T>> | null> {
+    return new RecordSchema(this.item, true);
+  }
+
+  serialize(): SerializedRecordSchema {
+    return {
+      type: "record",
+      item: this.item.serialize(),
+      opt: this.opt,
+    };
+  }
+}
+
+export const record = <S extends Schema<SelectorSource>>(
+  schema: S
+): Schema<Record<string, SchemaTypeOf<S>>> => {
+  return new RecordSchema(schema);
+};

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

@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Schema, SerializedSchema } from ".";
-import { SelectorSource } from "../selector";
+import { SelectorSource } from "../selector/index";
 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];