@valbuild/core 0.15.0 → 0.17.0

package/src/module.ts

@@ -4,16 +4,15 @@ import {
   GenericSelector,
   SelectorOf,
   SelectorSource,
-  SourceOrExpr,
+  GetSource,
+  GetSchema,
+  Path,
 } from "./selector";
-import { Source, SourceArray } from "./source";
-import { newSelectorProxy } from "./selector/SelectorProxy";
+import { Source } from "./source";
 import { ModuleId, ModulePath, SourcePath } from "./val";
 import { Expr } from "./expr";
 import { ArraySchema, SerializedArraySchema } from "./schema/array";
-import { I18nSchema, SerializedI18nSchema } from "./schema/i18n";
 import { UnionSchema, SerializedUnionSchema } from "./schema/union";
-import { OneOfSchema, SerializedOneOfSchema } from "./schema/oneOf";
 import { Json } from "./Json";
 import { RichTextSchema, SerializedRichTextSchema } from "./schema/richtext";
 import {
@@ -43,11 +42,15 @@ export function content<T extends Schema<SelectorSource>>(
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   source: SchemaTypeOf<T>
 ): ValModule<SchemaTypeOf<T>> {
-  return newSelectorProxy(source, id as SourcePath, schema);
+  return {
+    [GetSource]: source,
+    [GetSchema]: schema,
+    [Path]: id as SourcePath,
+  } as unknown as ValModule<SchemaTypeOf<T>>;
 }
 
-export function getRawSource(valModule: ValModule<SelectorSource>): Source {
-  const sourceOrExpr = valModule[SourceOrExpr];
+export function getSource(valModule: ValModule<SelectorSource>): Source {
+  const sourceOrExpr = valModule[GetSource];
   if (sourceOrExpr instanceof Expr) {
     throw Error("Cannot get raw source of an Expr");
   }
@@ -100,14 +103,14 @@ function isArraySchema(
   );
 }
 
-function isI18nSchema(
-  schema: Schema<SelectorSource> | SerializedSchema
-): schema is I18nSchema<readonly string[]> | SerializedI18nSchema {
-  return (
-    schema instanceof I18nSchema ||
-    (typeof schema === "object" && "type" in schema && schema.type === "i18n")
-  );
-}
+// function isI18nSchema(
+//   schema: Schema<SelectorSource> | SerializedSchema
+// ): schema is I18nSchema<readonly string[]> | SerializedI18nSchema {
+//   return (
+//     schema instanceof I18nSchema ||
+//     (typeof schema === "object" && "type" in schema && schema.type === "i18n")
+//   );
+// }
 
 function isUnionSchema(
   schema: Schema<SelectorSource> | SerializedSchema
@@ -144,15 +147,14 @@ function isImageSchema(
   );
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function isOneOfSchema(
-  schema: Schema<SelectorSource> | SerializedSchema
-): schema is OneOfSchema<GenericSelector<SourceArray>> | SerializedOneOfSchema {
-  return (
-    schema instanceof OneOfSchema ||
-    (typeof schema === "object" && "type" in schema && schema.type === "oneOf")
-  );
-}
+// function isOneOfSchema(
+//   schema: Schema<SelectorSource> | SerializedSchema
+// ): schema is OneOfSchema<GenericSelector<SourceArray>> | SerializedOneOfSchema {
+//   return (
+//     schema instanceof OneOfSchema ||
+//     (typeof schema === "object" && "type" in schema && schema.type === "oneOf")
+//   );
+// }
 
 export function resolvePath(
   path: ModulePath,
@@ -204,23 +206,23 @@ export function resolvePath(
       }
       resolvedSource = resolvedSource[part];
       resolvedSchema = resolvedSchema.items[part];
-    } else if (isI18nSchema(resolvedSchema)) {
-      if (!resolvedSchema.locales.includes(part)) {
-        throw Error(
-          `Invalid path: i18n schema ${resolvedSchema} supports locales ${resolvedSchema.locales.join(
-            ", "
-          )}, but found: ${part}`
-        );
-      }
-      if (!Object.keys(resolvedSource).includes(part)) {
-        throw Error(
-          `Schema type error: expected source to be type of i18n with locale ${part}, but got ${JSON.stringify(
-            Object.keys(resolvedSource)
-          )}`
-        );
-      }
-      resolvedSource = resolvedSource[part];
-      resolvedSchema = resolvedSchema.item;
+      // } else if (isI18nSchema(resolvedSchema)) {
+      //   if (!resolvedSchema.locales.includes(part)) {
+      //     throw Error(
+      //       `Invalid path: i18n schema ${resolvedSchema} supports locales ${resolvedSchema.locales.join(
+      //         ", "
+      //       )}, but found: ${part}`
+      //     );
+      //   }
+      //   if (!Object.keys(resolvedSource).includes(part)) {
+      //     throw Error(
+      //       `Schema type error: expected source to be type of i18n with locale ${part}, but got ${JSON.stringify(
+      //         Object.keys(resolvedSource)
+      //       )}`
+      //     );
+      //   }
+      //   resolvedSource = resolvedSource[part];
+      //   resolvedSchema = resolvedSchema.item;
     } else if (isImageSchema(resolvedSchema)) {
       return {
         path: origParts
@@ -270,7 +272,15 @@ export function resolvePath(
     throw Error(`Invalid path: ${parts.join(".")} is not a valid path`);
   }
   return {
-    path,
+    path: origParts
+      .map((p) => {
+        if (!Number.isNaN(Number(p))) {
+          return p;
+        } else {
+          return JSON.stringify(p);
+        }
+      })
+      .join("."), // TODO: create a function generate path from parts (not sure if this always works)
     schema: resolvedSchema,
     source: resolvedSource,
   };

package/src/patch/deref.test.ts

@@ -1,6 +1,6 @@
 import { file } from "../source/file";
 import { result } from "../fp";
-import { remote } from "../source/remote";
+import { remote } from "../source/future/remote";
 import { derefPatch, DerefPatchResult } from "./deref";
 import { JSONOps } from "./json";
 import { PatchError } from "./ops";

package/src/patch/deref.ts

@@ -1,6 +1,6 @@
 import { FILE_REF_PROP, isFile } from "../source/file";
 import { result } from "../fp";
-import { isRemote, REMOTE_REF_PROP } from "../source/remote";
+import { isRemote, REMOTE_REF_PROP } from "../source/future/remote";
 import { Ops, PatchError } from "./ops";
 import { Patch } from "./patch";
 

package/src/patch/index.ts

@@ -8,4 +8,5 @@ export {
   deepEqual,
   deepClone,
   parseAndValidateArrayIndex,
+  sourceToPatchPath,
 } from "./util";

package/src/patch/json.test.ts

@@ -1,4 +1,3 @@
-import { describe, test, expect } from "@jest/globals";
 import { JSONOps } from "./json";
 import * as result from "../fp/result";
 import { PatchError, JSONValue } from "./ops";

package/src/patch/util.ts

@@ -1,5 +1,7 @@
 import { array, result } from "../fp";
 import { PatchError, ReadonlyJSONValue, ToMutable } from "./ops";
+import { splitModuleIdAndModulePath } from "../module";
+import { SourcePath } from "../val";
 
 export function isNotRoot(path: string[]): path is array.NonEmptyArray<string> {
   return array.isNonEmpty(path);
@@ -65,3 +67,8 @@ export function parseAndValidateArrayIndex(
   }
   return result.ok(Number(value));
 }
+
+export function sourceToPatchPath(sourcePath: SourcePath) {
+  const [, modulePath] = splitModuleIdAndModulePath(sourcePath);
+  return modulePath.split(".").map((p) => JSON.parse(p).toString());
+}

package/src/schema/array.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 SerializedArraySchema = {
   type: "array";
@@ -16,11 +18,46 @@ export class ArraySchema<T extends Schema<SelectorSource>> extends Schema<
     super();
   }
 
-  validate(src: SchemaTypeOf<T>[]): false | Record<SourcePath, string[]> {
-    throw new Error("Method not implemented.");
+  validate(path: SourcePath, src: SchemaTypeOf<T>[]): ValidationErrors {
+    let error: ValidationErrors = false;
+
+    if (this.opt && (src === null || src === undefined)) {
+      return false;
+    }
+
+    if (typeof src !== "object" || !Array.isArray(src)) {
+      return {
+        [path]: [{ message: `Expected 'array', got '${typeof src}'` }],
+      } as ValidationErrors;
+    }
+    src.forEach((i, idx) => {
+      const subPath = createValPathOfItem(path, idx);
+      if (!subPath) {
+        error = this.appendValidationError(
+          error,
+          path,
+          `Internal error: could not create path at ${
+            !path && typeof path === "string" ? "<empty string>" : path
+          } at index ${idx}`, // Should! never happen
+          src
+        );
+      } else {
+        const subError = this.item.validate(subPath, i);
+        if (subError && error) {
+          error = {
+            ...subError,
+            ...error,
+          };
+        } else if (subError) {
+          error = subError;
+        }
+      }
+    });
+
+    return error;
   }
 
-  match(src: SchemaTypeOf<T>[]): boolean {
+  assert(src: SchemaTypeOf<T>[]): boolean {
     if (this.opt && (src === null || src === undefined)) {
       return true;
     }
@@ -28,7 +65,11 @@ export class ArraySchema<T extends Schema<SelectorSource>> extends Schema<
       return false;
     }
 
-    // TODO: checks all items
+    for (const item of src) {
+      if (!this.item.assert(item)) {
+        return false;
+      }
+    }
     return typeof src === "object" && Array.isArray(src);
   }
 

package/src/schema/boolean.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 SerializedBooleanSchema = {
   type: "boolean";
@@ -11,11 +12,21 @@ export class BooleanSchema<Src extends boolean | null> extends Schema<Src> {
   constructor(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 !== "boolean") {
+      return {
+        [path]: [
+          { message: `Expected 'boolean', 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/{i18n.ts → future/i18n.ts}

@@ -1,7 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { Schema, SchemaTypeOf, SerializedSchema } from ".";
-import { I18nCompatibleSource, I18nSource } from "../source/i18n";
-import { SourcePath } from "../val";
+import { Schema, SchemaTypeOf, SerializedSchema } from "..";
+import { I18nCompatibleSource, I18nSource } from "../../source/future/i18n";
+import { SourcePath } from "../../val";
+import { ValidationErrors } from "../validation/ValidationError";
 
 export type SerializedI18nSchema = {
   type: "i18n";
@@ -22,12 +23,13 @@ export class I18nSchema<Locales extends readonly string[]> extends Schema<
   }
 
   validate(
+    path: SourcePath,
     src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>
-  ): false | Record<SourcePath, string[]> {
+  ): ValidationErrors {
     throw new Error("Method not implemented.");
   }
 
-  match(
+  assert(
     src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>
   ): boolean {
     throw new Error("Method not implemented.");
@@ -41,12 +43,14 @@ export class I18nSchema<Locales extends readonly string[]> extends Schema<
   }
 
   serialize(): SerializedSchema {
-    return {
-      type: "i18n",
-      item: this.item.serialize(),
-      locales: this.locales,
-      opt: this.opt,
-    };
+    throw new Error("Method not implemented.");
+
+    // return {
+    //   type: "i18n",
+    //   item: this.item.serialize(),
+    //   locales: this.locales,
+    //   opt: this.opt,
+    // };
   }
 }
 

package/src/schema/{oneOf.ts → future/oneOf.ts}

@@ -1,9 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { Schema, SerializedSchema } from ".";
-import { ValModuleBrand } from "../module";
-import { GenericSelector } from "../selector";
-import { Source, SourceArray } from "../source";
-import { getValPath, SourcePath } from "../val";
+import { Schema, SerializedSchema } from "..";
+import { ValModuleBrand } from "../../module";
+import { GenericSelector } from "../../selector/future";
+import { Source, SourceArray } from "../../source";
+import { 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> {
@@ -37,17 +38,19 @@ export class OneOfSchema<
   }
 
   serialize(): SerializedSchema {
-    const path = getValPath(this.selector);
-    if (!path) {
-      throw new Error(
-        "Cannot serialize oneOf schema with empty selector. Make sure a Val module is used."
-      );
-    }
-    return {
-      type: "oneOf",
-      selector: path,
-      opt: this.opt,
-    };
+    throw new Error("Method not implemented.");
+
+    // const path = getValPath(this.selector);
+    // if (!path) {
+    //   throw new Error(
+    //     "Cannot serialize oneOf schema with empty selector. Make sure a Val module is used."
+    //   );
+    // }
+    // return {
+    //   type: "oneOf",
+    //   selector: path,
+    //   opt: this.opt,
+    // };
   }
 }
 

package/src/schema/image.ts

@@ -1,7 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Schema, SerializedSchema } from ".";
+import { VAL_EXTENSION } from "../source";
 import { FileSource, FILE_REF_PROP } from "../source/file";
 import { SourcePath } from "../val";
+import { ValidationErrors } from "./validation/ValidationError";
 
 export type ImageOptions = {
   ext: ["jpg"] | ["webp"];
@@ -29,13 +31,71 @@ export class ImageSchema<
     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 (src === null || src === undefined) {
+      return {
+        [path]: [
+          {
+            message: `Non-optional image was null or undefined.`,
+            value: src,
+          },
+        ],
+      } as ValidationErrors;
+    }
+    if (typeof src[FILE_REF_PROP] !== "string") {
+      return {
+        [path]: [
+          {
+            message: `Image did not have a file reference string. Got: ${typeof src[
+              FILE_REF_PROP
+            ]}`,
+            value: src,
+          },
+        ],
+      } as ValidationErrors;
+    }
+
+    if (src[VAL_EXTENSION] !== "file") {
+      return {
+        [path]: [
+          {
+            message: `Image did not have the valid file extension type. Got: ${src[VAL_EXTENSION]}`,
+            value: src,
+          },
+        ],
+      } as ValidationErrors;
+    }
+    if (src.metadata) {
+      return {
+        [path]: [
+          {
+            message: `Found metadata, but it could not be validated. Image metadata must be an object with the required props: width (positive number), height (positive number) and sha256 (string of length 64 of the base16 hash).`, // These validation errors will have to be picked up by logic outside of this package and revalidated. Reasons: 1) we have to read files to verify the metadata, which is handled differently in different runtimes (Browser, QuickJS, Node.js); 2) we want to keep this package dependency free.
+            value: src,
+            fixes: ["image:replace-metadata"],
+          },
+        ],
+      } as ValidationErrors;
+    }
+
+    return {
+      [path]: [
+        {
+          message: `Could not validate Image metadata.`,
+          value: src,
+          fixes: ["image:add-metadata"],
+        },
+      ],
+    } as ValidationErrors;
   }
 
-  match(src: Src): boolean {
-    // TODO:
-    return true;
+  assert(src: Src): boolean {
+    if (this.opt && (src === null || src === undefined)) {
+      return true;
+    }
+    return src?.[FILE_REF_PROP] === "image" && src?.[VAL_EXTENSION] === "file";
   }
 
   optional(): Schema<Src | null> {
@@ -57,7 +117,7 @@ export const image = (
   return new ImageSchema(options);
 };
 
-export const convertImageSource = (
+export const convertFileSource = (
   src: FileSource<ImageMetadata>
 ): { url: string; metadata?: ImageMetadata } => {
   // TODO: /public should be configurable

package/src/schema/index.ts

@@ -1,41 +1,65 @@
 import { SelectorSource } from "../selector";
-import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
+// import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
 import { SourcePath } from "../val";
 import { SerializedArraySchema } from "./array";
 import { SerializedBooleanSchema } from "./boolean";
-import { SerializedI18nSchema } from "./i18n";
 import { SerializedImageSchema } from "./image";
+import { SerializedKeyOfSchema } from "./keyOf";
 import { SerializedLiteralSchema } from "./literal";
 import { SerializedNumberSchema } from "./number";
 import { SerializedObjectSchema } from "./object";
-import { SerializedOneOfSchema } from "./oneOf";
+import { SerializedRecordSchema } from "./record";
 import { SerializedRichTextSchema } from "./richtext";
 import { SerializedStringSchema } from "./string";
 import { SerializedUnionSchema } from "./union";
+import { ValidationErrors } from "./validation/ValidationError";
+// import { SerializedI18nSchema } from "./future/i18n";
+// import { SerializedOneOfSchema } from "./future/oneOf";
 
 export type SerializedSchema =
+  // | SerializedOneOfSchema
+  // | SerializedI18nSchema
   | SerializedStringSchema
   | SerializedLiteralSchema
   | SerializedBooleanSchema
   | SerializedNumberSchema
   | SerializedObjectSchema
-  | SerializedOneOfSchema
   | SerializedArraySchema
   | SerializedUnionSchema
   | SerializedRichTextSchema
-  | SerializedImageSchema
-  | SerializedI18nSchema;
+  | SerializedRecordSchema
+  | SerializedKeyOfSchema
+  | SerializedImageSchema;
 
 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
-    ? Schema<RemoteSource<Src>>
-    : never {
-    // TODO: Schema<never, "Cannot create remote schema from non-remote source.">
-    throw new Error("You need Val Ultra to use .remote()");
+  // remote(): Src extends RemoteCompatibleSource
+  //   ? Schema<RemoteSource<Src>>
+  //   : never {
+  //   // 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;
+    }
   }
 }