@valbuild/core 0.25.0 → 0.27.0

package/src/schema/richtext.ts

@@ -1,44 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { Schema, SerializedSchema } from ".";
-import { RichTextSource, RichTextOptions } from "../source/richtext";
-import { SourcePath } from "../val";
-import { ValidationErrors } from "./validation/ValidationError";
-
-export type SerializedRichTextSchema = RichTextOptions & {
-  type: "richtext";
-  opt: boolean;
-};
-
-export class RichTextSchema<
-  O extends RichTextOptions,
-  Src extends RichTextSource<O> | null
-> extends Schema<Src> {
-  constructor(readonly options: O, readonly opt: boolean = false) {
-    super();
-  }
-
-  validate(path: SourcePath, src: Src): ValidationErrors {
-    return false; //TODO
-  }
-
-  assert(src: Src): boolean {
-    return true; // TODO
-  }
-
-  optional(): Schema<RichTextSource<O> | null> {
-    return new RichTextSchema(this.options, true);
-  }
-
-  serialize(): SerializedSchema {
-    return {
-      type: "richtext",
-      opt: this.opt,
-    };
-  }
-}
-
-export const richtext = <O extends RichTextOptions>(
-  options?: O
-): Schema<RichTextSource<O>> => {
-  return new RichTextSchema<O, RichTextSource<O>>(options ?? ({} as O));
-};

package/src/schema/string.ts

@@ -1,95 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { Schema, SerializedSchema } from ".";
-import { SourcePath } from "../val";
-import { ValidationErrors } from "./validation/ValidationError";
-
-type StringOptions = {
-  maxLength?: number;
-  minLength?: number;
-};
-
-export type SerializedStringSchema = {
-  type: "string";
-  options?: StringOptions;
-  opt: boolean;
-  raw: boolean;
-};
-
-const brand = Symbol("string");
-export type RawString = string & { readonly [brand]: "raw" };
-
-export class StringSchema<Src extends string | null> extends Schema<Src> {
-  constructor(
-    readonly options?: StringOptions,
-    readonly opt: boolean = false,
-    private readonly isRaw: 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;
-    }
-    const errors = [];
-    if (this.options?.maxLength && src.length > this.options.maxLength) {
-      errors.push({
-        message: `Expected string to be at most ${this.options.maxLength} characters long, got ${src.length}`,
-        value: src,
-      });
-    }
-    if (this.options?.minLength && src.length < this.options.minLength) {
-      errors.push({
-        message: `Expected string to be at least ${this.options.minLength} characters long, got ${src.length}`,
-        value: src,
-      });
-    }
-    if (errors.length > 0) {
-      return {
-        [path]: errors,
-      } as ValidationErrors;
-    }
-    return false;
-  }
-
-  assert(src: Src): boolean {
-    if (this.opt && (src === null || src === undefined)) {
-      return true;
-    }
-    return typeof src === "string";
-  }
-
-  optional(): StringSchema<Src | null> {
-    return new StringSchema<Src | null>(this.options, true, this.isRaw);
-  }
-
-  raw(): StringSchema<Src extends null ? RawString | null : RawString> {
-    return new StringSchema<Src extends null ? RawString | null : RawString>(
-      this.options,
-      this.opt,
-      true
-    );
-  }
-
-  serialize(): SerializedSchema {
-    return {
-      type: "string",
-      options: this.options,
-      opt: this.opt,
-      raw: this.isRaw,
-    };
-  }
-}
-
-export const string = <T extends string>(
-  options?: StringOptions
-): StringSchema<T> => {
-  return new StringSchema(options);
-};

package/src/schema/union.ts

@@ -1,63 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { Schema, SerializedSchema } from ".";
-import { SelectorSource } from "../selector/index";
-import { SourceObject } from "../source";
-import { SourcePath } from "../val";
-import { ValidationErrors } from "./validation/ValidationError";
-
-export type SerializedUnionSchema = {
-  type: "union";
-  key: string;
-  items: SerializedSchema[];
-  opt: boolean;
-};
-
-type SourceOf<
-  Key extends string,
-  T extends Schema<SourceObject & { [k in Key]: string }>[]
-> = T extends Schema<infer S>[]
-  ? S extends SelectorSource
-    ? S
-    : never
-  : never;
-
-export class UnionSchema<
-  Key extends string,
-  T extends Schema<SourceObject & { [k in Key]: string }>[]
-> extends Schema<SourceOf<Key, T>> {
-  validate(path: SourcePath, src: SourceOf<Key, T>): ValidationErrors {
-    throw new Error("Method not implemented.");
-  }
-  assert(src: SourceOf<Key, T>): boolean {
-    throw new Error("Method not implemented.");
-  }
-  optional(): Schema<SourceOf<Key, T> | null> {
-    throw new Error("Method not implemented.");
-  }
-  serialize(): SerializedSchema {
-    return {
-      type: "union",
-      key: this.key,
-      items: this.items.map((o) => o.serialize()),
-      opt: this.opt,
-    };
-  }
-
-  constructor(
-    readonly key: Key,
-    readonly items: T,
-    readonly opt: boolean = false
-  ) {
-    super();
-  }
-}
-
-export const union = <
-  Key extends string,
-  T extends Schema<SourceObject & { [k in Key]: string }>[]
->(
-  key: Key,
-  ...objects: T
-): Schema<SourceOf<Key, T>> => {
-  return new UnionSchema(key, objects);
-};

package/src/schema/validation/ValidationError.ts

@@ -1,16 +0,0 @@
-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

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

package/src/schema/validation.test.ts

@@ -1,291 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-import { createValPathOfItem } from "../selector/future/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";
-import { record } from "./record";
-import { keyOf } from "./keyOf";
-import { content } from "../module";
-
-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: "failing object(string)",
-    input: { one: "one val", two: 1 },
-    schema: object({
-      one: string(),
-      two: string(),
-    }),
-    expected: [pathOf("two")],
-  },
-  // record
-  {
-    description: "basic record(string)",
-    input: { one: "one val", two: "two val" },
-    schema: record(string()),
-    expected: false,
-  },
-  {
-    description: "failing record(string)",
-    input: { one: "one val", two: 1 },
-    schema: object({
-      one: string(),
-      two: string(),
-    }),
-    expected: [pathOf("two")],
-  },
-  // keyof
-  {
-    description: "basic keyOf(array)",
-    input: 1,
-    schema: keyOf(content("/keyof-module", array(string()), [])),
-    expected: false,
-  },
-  {
-    description: "failing keyOf(record)",
-    input: "1",
-    schema: keyOf(content("/keyof-module", array(string()), [])),
-    expected: [testPath],
-  },
-  {
-    description: "basic keyOf(record)",
-    input: "one",
-    schema: keyOf(content("/keyof-module", record(string()), {})),
-    expected: false,
-  },
-  {
-    description: "failing keyOf(record)",
-    input: 1,
-    schema: keyOf(content("/keyof-module", record(string()), {})),
-    expected: [testPath],
-  },
-  {
-    description: "basic keyOf(object)",
-    input: "test1",
-    schema: keyOf(
-      content("/keyof-module", object({ test1: string(), test2: string() }), {
-        test1: "",
-        test2: "",
-      })
-    ),
-    expected: false,
-  },
-  {
-    description: "failing keyOf(object)",
-    input: "test",
-    schema: keyOf(
-      content("/keyof-module", object({ test1: string(), test2: string() }), {
-        test1: "",
-        test2: "",
-      })
-    ),
-    expected: [testPath],
-  },
-  // 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: replace metadata",
-    input: fileVal("test", {
-      width: 100,
-      height: 100,
-      sha256: "test",
-    }),
-    schema: image(),
-    expected: [testPath],
-    fixes: {
-      [testPath]: ["image:replace-metadata"],
-    },
-  },
-  {
-    description: "failure image: check metadata",
-    input: fileVal("test", {
-      width: 100,
-      height: 100,
-      sha256:
-        "9e420dc93157ab98338542ba6f1d34fcf829d646aa729a86720fa3f4cb2d0076",
-    }),
-    schema: image(),
-    expected: [testPath],
-    fixes: {
-      [testPath]: ["image:replace-metadata"],
-    },
-  },
-  // richtext
-  {
-    description: "basic richtext",
-    input: richtextVal`test`,
-    expected: false,
-    schema: richtext({ bold: true }),
-  },
-  // 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);
-      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);
-      }
-    }
-  );
-});