@valbuild/core 0.16.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/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/schema/{i18n.ts → future/i18n.ts}

@@ -1,8 +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 { ValidationErrors } from "./validation/ValidationError";
+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";
@@ -43,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,10 +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 { ValidationErrors } from "./validation/ValidationError";
+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";
@@ -38,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

@@ -117,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,44 +1,47 @@
-import { Json } from "../Json";
 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(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(

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

@@ -1,6 +1,6 @@
 /* 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";