@valbuild/core 0.26.0 → 0.27.0

package/src/schema/image.ts

@@ -1,137 +0,0 @@
-/* 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"];
-  directory?: string;
-  prefix?: string;
-};
-
-export type SerializedImageSchema = {
-  type: "image";
-  options?: ImageOptions;
-  opt: boolean;
-};
-
-export type ImageMetadata =
-  | {
-      width: number;
-      height: number;
-      sha256: string;
-    }
-  | undefined;
-export class ImageSchema<
-  Src extends FileSource<ImageMetadata> | null
-> extends Schema<Src> {
-  constructor(readonly options?: ImageOptions, readonly opt: boolean = false) {
-    super();
-  }
-
-  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;
-  }
-
-  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> {
-    return new ImageSchema<Src | null>(this.options, true);
-  }
-
-  serialize(): SerializedSchema {
-    return {
-      type: "image",
-      options: this.options,
-      opt: this.opt,
-    };
-  }
-}
-
-export const image = (
-  options?: ImageOptions
-): Schema<FileSource<ImageMetadata>> => {
-  return new ImageSchema(options);
-};
-
-export const convertFileSource = (
-  src: FileSource<ImageMetadata>
-): { url: string; metadata?: ImageMetadata } => {
-  // TODO: /public should be configurable
-  if (!src[FILE_REF_PROP].startsWith("/public")) {
-    return {
-      url: src[FILE_REF_PROP] + `?sha256=${src.metadata?.sha256}`,
-      metadata: src.metadata,
-    };
-  }
-
-  return {
-    url:
-      src[FILE_REF_PROP].slice("/public".length) +
-      `?sha256=${src.metadata?.sha256}`,
-    metadata: src.metadata,
-  };
-};

package/src/schema/index.ts

@@ -1,70 +0,0 @@
-import { SelectorSource } from "../selector";
-// import { RemoteCompatibleSource, RemoteSource } from "../source/remote";
-import { SourcePath } from "../val";
-import { SerializedArraySchema } from "./array";
-import { SerializedBooleanSchema } from "./boolean";
-import { SerializedImageSchema } from "./image";
-import { SerializedKeyOfSchema } from "./keyOf";
-import { SerializedLiteralSchema } from "./literal";
-import { SerializedNumberSchema } from "./number";
-import { SerializedObjectSchema } from "./object";
-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
-  | SerializedArraySchema
-  | SerializedUnionSchema
-  | SerializedRichTextSchema
-  | 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()");
-  // }
-
-  /** 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<
-  infer Src
->
-  ? Src
-  : never; // TODO: SourceError<"Could not determine type of Schema">

package/src/schema/keyOf.ts

@@ -1,167 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { Schema, SerializedSchema } from "../schema";
-import { ValModuleBrand } from "../module";
-import { GenericSelector, GetSchema } from "../selector";
-import { SourceArray, SourceObject } 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,63 +0,0 @@
-/* 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";
-  value: string;
-  opt: boolean;
-};
-
-export class LiteralSchema<Src extends string | null> extends Schema<Src> {
-  constructor(readonly value: string, readonly opt: boolean = false) {
-    super();
-  }
-
-  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;
-  }
-
-  assert(src: Src): boolean {
-    if (this.opt && (src === null || src === undefined)) {
-      return true;
-    }
-    return typeof src === "string";
-  }
-
-  optional(): Schema<Src | null> {
-    return new LiteralSchema<Src | null>(this.value, true);
-  }
-
-  serialize(): SerializedSchema {
-    return {
-      type: "literal",
-      value: this.value,
-      opt: this.opt,
-    };
-  }
-}
-
-export const literal = <T extends string>(value: T): Schema<T> => {
-  return new LiteralSchema(value);
-};

package/src/schema/number.ts

@@ -1,56 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { Schema, SerializedSchema } from ".";
-import { SourcePath } from "../val";
-import { ValidationErrors } from "./validation/ValidationError";
-
-type NumberOptions = {
-  max?: number;
-  min?: number;
-};
-
-export type SerializedNumberSchema = {
-  type: "number";
-  options?: NumberOptions;
-  opt: boolean;
-};
-
-export class NumberSchema<Src extends number | null> extends Schema<Src> {
-  constructor(readonly options?: NumberOptions, readonly opt: boolean = false) {
-    super();
-  }
-  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;
-  }
-
-  assert(src: Src): boolean {
-    if (this.opt && (src === null || src === undefined)) {
-      return true;
-    }
-    return typeof src === "number";
-  }
-
-  optional(): Schema<Src | null> {
-    return new NumberSchema<Src | null>(this.options, true);
-  }
-  serialize(): SerializedSchema {
-    return {
-      type: "number",
-      options: this.options,
-      opt: this.opt,
-    };
-  }
-}
-
-export const number = (options?: NumberOptions): Schema<number> => {
-  return new NumberSchema(options);
-};

package/src/schema/object.ts

@@ -1,110 +0,0 @@
-/* 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";
-  items: Record<string, SerializedSchema>;
-  opt: boolean;
-};
-
-type ObjectSchemaProps = { [key: string]: Schema<SelectorSource> };
-type ObjectSchemaSrcOf<Props extends ObjectSchemaProps> = {
-  [key in keyof Props]: SchemaTypeOf<Props[key]>;
-};
-
-export class ObjectSchema<Props extends ObjectSchemaProps> extends Schema<
-  ObjectSchemaSrcOf<Props>
-> {
-  constructor(readonly items: Props, readonly opt: boolean = false) {
-    super();
-  }
-
-  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;
-  }
-
-  assert(src: ObjectSchemaSrcOf<Props>): boolean {
-    if (this.opt && (src === null || src === undefined)) {
-      return true;
-    }
-    if (!src) {
-      return false;
-    }
-
-    for (const [key, schema] of Object.entries(this.items)) {
-      if (!schema.assert(src[key])) {
-        return false;
-      }
-    }
-    return typeof src === "object" && !Array.isArray(src);
-  }
-
-  optional(): Schema<ObjectSchemaSrcOf<Props> | null> {
-    return new ObjectSchema(this.items, true);
-  }
-
-  serialize(): SerializedSchema {
-    return {
-      type: "object",
-      items: Object.fromEntries(
-        Object.entries(this.items).map(([key, schema]) => [
-          key,
-          schema.serialize(),
-        ])
-      ),
-      opt: this.opt,
-    };
-  }
-}
-
-export const object = <Props extends ObjectSchemaProps>(
-  schema: Props
-): Schema<{
-  [key in keyof Props]: SchemaTypeOf<Props[key]>;
-}> => {
-  return new ObjectSchema(schema);
-};

package/src/schema/record.ts

@@ -1,103 +0,0 @@
-/* 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);
-};