@valbuild/core 0.12.0 → 0.13.0

package/src/patch/parse.ts

@@ -0,0 +1,187 @@
+import { array, pipe, result } from "../fp";
+import { Operation, OperationJSON } from "./operation";
+import { Patch, PatchJSON } from "./patch";
+
+function parseJSONPointerReferenceToken(value: string): string | undefined {
+  if (value.endsWith("~")) {
+    return undefined;
+  }
+  try {
+    return value.replace(/~./, (escaped) => {
+      switch (escaped) {
+        case "~0":
+          return "~";
+        case "~1":
+          return "/";
+      }
+      throw new Error();
+    });
+  } catch (e) {
+    return undefined;
+  }
+}
+
+export function parseJSONPointer(
+  pointer: string
+): result.Result<string[], string> {
+  if (pointer === "/") return result.ok([]);
+  if (!pointer.startsWith("/"))
+    return result.err("JSON pointer must start with /");
+
+  const tokens = pointer
+    .substring(1)
+    .split("/")
+    .map(parseJSONPointerReferenceToken);
+  if (
+    tokens.every(
+      (token: string | undefined): token is string => token !== undefined
+    )
+  ) {
+    return result.ok(tokens);
+  } else {
+    return result.err("Invalid JSON pointer escape sequence");
+  }
+}
+
+export function formatJSONPointerReferenceToken(key: string): string {
+  return key.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+
+export function formatJSONPointer(path: string[]): string {
+  return `/${path.map(formatJSONPointerReferenceToken).join("/")}`;
+}
+
+/**
+ * A signifies an issue that makes a PatchJSON or an OperationJSON invalid.
+ * Unlike PatchError, a StaticPatchIssue indicates an issue with the patch
+ * document itself; it is independent of any document which the patch or
+ * might be applied to.
+ */
+export type StaticPatchIssue = {
+  path: string[];
+  message: string;
+};
+
+export function prefixIssuePath(
+  prefix: string,
+  { path, message }: StaticPatchIssue
+): StaticPatchIssue {
+  return { path: [prefix, ...path], message };
+}
+
+function createIssueAtPath(path: string[]) {
+  return (message: string): StaticPatchIssue => ({
+    path,
+    message,
+  });
+}
+
+function isProperPathPrefix(prefix: string[], path: string[]): boolean {
+  if (prefix.length >= path.length) {
+    // A proper prefix cannot be longer or have the same length as the path
+    return false;
+  }
+  for (let i = 0; i < prefix.length; ++i) {
+    if (prefix[i] !== path[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function parseOperation(
+  operation: OperationJSON
+): result.Result<Operation, array.NonEmptyArray<StaticPatchIssue>> {
+  const path = parseJSONPointer(operation.path);
+
+  switch (operation.op) {
+    case "add":
+    case "replace":
+    case "test":
+      return pipe(
+        path,
+        result.mapErr(
+          (error: string): array.NonEmptyArray<StaticPatchIssue> => [
+            createIssueAtPath(["path"])(error),
+          ]
+        ),
+        result.map((path: string[]) => ({
+          op: operation.op,
+          path,
+          value: operation.value,
+        }))
+      );
+    case "remove":
+      return pipe(
+        path,
+        result.filterOrElse(array.isNonEmpty, () => "Cannot remove root"),
+        result.mapErr(
+          (error: string): array.NonEmptyArray<StaticPatchIssue> => [
+            createIssueAtPath(["path"])(error),
+          ]
+        ),
+        result.map((path: array.NonEmptyArray<string>) => ({
+          op: operation.op,
+          path,
+        }))
+      );
+    case "move":
+      return pipe(
+        result.allT<
+          [from: array.NonEmptyArray<string>, path: string[]],
+          StaticPatchIssue
+        >([
+          pipe(
+            parseJSONPointer(operation.from),
+            result.filterOrElse(array.isNonEmpty, () => "Cannot move root"),
+            result.mapErr(createIssueAtPath(["from"]))
+          ),
+          pipe(path, result.mapErr(createIssueAtPath(["path"]))),
+        ]),
+        result.filterOrElse(
+          ([from, path]) => !isProperPathPrefix(from, path),
+          (): array.NonEmptyArray<StaticPatchIssue> => [
+            createIssueAtPath(["from"])("Cannot be a proper prefix of path"),
+          ]
+        ),
+        result.map(([from, path]) => ({
+          op: operation.op,
+          from,
+          path,
+        }))
+      );
+    case "copy":
+      return pipe(
+        result.allT<[from: string[], path: string[]], StaticPatchIssue>([
+          pipe(
+            parseJSONPointer(operation.from),
+            result.mapErr(createIssueAtPath(["from"]))
+          ),
+          pipe(path, result.mapErr(createIssueAtPath(["path"]))),
+        ]),
+        result.map(([from, path]) => ({
+          op: operation.op,
+          from,
+          path,
+        }))
+      );
+  }
+}
+
+export function parsePatch(
+  patch: PatchJSON
+): result.Result<Patch, array.NonEmptyArray<StaticPatchIssue>> {
+  return pipe(
+    patch
+      .map(parseOperation)
+      .map(
+        result.mapErr(
+          array.map((error: StaticPatchIssue, index: number) =>
+            prefixIssuePath(index.toString(), error)
+          )
+        )
+      ),
+    result.all,
+    result.mapErr(array.flatten<StaticPatchIssue>)
+  );
+}

package/src/patch/patch.ts

@@ -0,0 +1,46 @@
+import { result, pipe } from "../fp";
+import { Ops, PatchError } from "./ops";
+import { Operation, OperationJSON } from "./operation";
+
+export type Patch = Operation[];
+export type PatchJSON = OperationJSON[];
+
+function apply<T, E>(
+  document: T,
+  ops: Ops<T, E>,
+  op: Operation
+): result.Result<T, E | PatchError> {
+  switch (op.op) {
+    case "add":
+      return ops.add(document, op.path, op.value);
+    case "remove":
+      return ops.remove(document, op.path);
+    case "replace":
+      return ops.replace(document, op.path, op.value);
+    case "move":
+      return ops.move(document, op.from, op.path);
+    case "copy":
+      return ops.copy(document, op.from, op.path);
+    case "test": {
+      if (!ops.test(document, op.path, op.value)) {
+        return result.err(new PatchError("Test failed"));
+      }
+      return result.ok(document);
+    }
+  }
+}
+
+export function applyPatch<T, E>(
+  document: T,
+  ops: Ops<T, E>,
+  patch: Operation[]
+): result.Result<T, E | PatchError> {
+  return pipe(
+    patch,
+    result.flatMapReduce(
+      (doc: T, op: Operation): result.Result<T, E | PatchError> =>
+        apply(doc, ops, op),
+      document
+    )
+  );
+}

package/src/patch/util.ts

@@ -0,0 +1,67 @@
+import { array, result } from "../fp";
+import { PatchError, ReadonlyJSONValue, ToMutable } from "./ops";
+
+export function isNotRoot(path: string[]): path is array.NonEmptyArray<string> {
+  return array.isNonEmpty(path);
+}
+
+export function deepEqual(a: ReadonlyJSONValue, b: ReadonlyJSONValue) {
+  if (a === b) {
+    return true;
+  }
+
+  if (
+    typeof a === "object" &&
+    typeof b === "object" &&
+    a !== null &&
+    b !== null
+  ) {
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+
+      for (let i = 0; i < a.length; ++i) {
+        if (!deepEqual(a[i], b[i])) return false;
+      }
+
+      return true;
+    } else if (!Array.isArray(a) && !Array.isArray(b)) {
+      const aEntries = Object.entries(a);
+      // If the objects have a different amount of keys, they cannot be equal
+      if (aEntries.length !== Object.keys(b).length) return false;
+
+      for (const [key, aValue] of aEntries) {
+        // b must be a JSON object, so the only way for the bValue to be
+        // undefined is if the key is unset
+        const bValue: ReadonlyJSONValue | undefined = (
+          b as { readonly [P in string]: ReadonlyJSONValue }
+        )[key];
+        if (bValue === undefined) return false;
+        if (!deepEqual(aValue, bValue)) return false;
+      }
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function deepClone<T extends ReadonlyJSONValue>(value: T): ToMutable<T> {
+  if (Array.isArray(value)) {
+    return value.map(deepClone) as ToMutable<T>;
+  } else if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, value]) => [key, deepClone(value)])
+    ) as ToMutable<T>;
+  } else {
+    return value as ToMutable<T>;
+  }
+}
+
+export function parseAndValidateArrayIndex(
+  value: string
+): result.Result<number, PatchError> {
+  if (!/^(0|[1-9][0-9]*)$/g.test(value)) {
+    return result.err(new PatchError(`Invalid array index "${value}"`));
+  }
+  return result.ok(Number(value));
+}

package/src/schema/array.ts

@@ -0,0 +1,52 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SchemaTypeOf, SerializedSchema } from ".";
+import { SelectorSource } from "../selector";
+import { SourcePath } from "../val";
+
+export type SerializedArraySchema = {
+  type: "array";
+  item: SerializedSchema;
+  opt: boolean;
+};
+
+export class ArraySchema<T extends Schema<SelectorSource>> extends Schema<
+  SchemaTypeOf<T>[]
+> {
+  constructor(readonly item: T, readonly opt: boolean = false) {
+    super();
+  }
+
+  validate(src: SchemaTypeOf<T>[]): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  match(src: SchemaTypeOf<T>[]): boolean {
+    if (this.opt && (src === null || src === undefined)) {
+      return true;
+    }
+    if (!src) {
+      return false;
+    }
+
+    // TODO: checks all items
+    return typeof src === "object" && Array.isArray(src);
+  }
+
+  optional(): Schema<SchemaTypeOf<T>[] | null> {
+    return new ArraySchema(this.item, true);
+  }
+
+  serialize(): SerializedArraySchema {
+    return {
+      type: "array",
+      item: this.item.serialize(),
+      opt: this.opt,
+    };
+  }
+}
+
+export const array = <S extends Schema<SelectorSource>>(
+  schema: S
+): Schema<SchemaTypeOf<S>[]> => {
+  return new ArraySchema(schema);
+};

package/src/schema/boolean.ts

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+
+export type SerializedBooleanSchema = {
+  type: "boolean";
+  opt: boolean;
+};
+
+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.");
+  }
+
+  match(src: Src): boolean {
+    if (this.opt && (src === null || src === undefined)) {
+      return true;
+    }
+    return typeof src === "boolean";
+  }
+
+  optional(): Schema<Src | null> {
+    return new BooleanSchema<Src | null>(true);
+  }
+  serialize(): SerializedSchema {
+    return {
+      type: "boolean",
+      opt: this.opt,
+    };
+  }
+}
+
+export const boolean = (): Schema<boolean> => {
+  return new BooleanSchema();
+};

package/src/schema/i18n.ts

@@ -0,0 +1,65 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SchemaTypeOf, SerializedSchema } from ".";
+import { I18nCompatibleSource, I18nSource } from "../source/i18n";
+import { SourcePath } from "../val";
+
+export type SerializedI18nSchema = {
+  type: "i18n";
+  locales: readonly string[];
+  item: SerializedSchema;
+  opt: boolean;
+};
+
+export class I18nSchema<Locales extends readonly string[]> extends Schema<
+  I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>
+> {
+  constructor(
+    readonly locales: Locales,
+    readonly item: Schema<SchemaTypeOf<Schema<I18nCompatibleSource>>>,
+    readonly opt: boolean = false
+  ) {
+    super();
+  }
+
+  validate(
+    src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>
+  ): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  match(
+    src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>
+  ): boolean {
+    throw new Error("Method not implemented.");
+  }
+
+  optional(): Schema<I18nSource<
+    Locales,
+    SchemaTypeOf<Schema<I18nCompatibleSource>>
+  > | null> {
+    return new I18nSchema(this.locales, this.item, true);
+  }
+
+  serialize(): SerializedSchema {
+    return {
+      type: "i18n",
+      item: this.item.serialize(),
+      locales: this.locales,
+      opt: this.opt,
+    };
+  }
+}
+
+export type I18n<Locales extends readonly string[]> = <
+  S extends Schema<I18nCompatibleSource>
+>(
+  schema: S
+) => Schema<I18nSource<Locales, SchemaTypeOf<S>>>;
+
+export const i18n =
+  <Locales extends readonly string[]>(locales: Locales) =>
+  <S extends Schema<I18nCompatibleSource>>(
+    schema: S
+  ): Schema<I18nSource<Locales, SchemaTypeOf<S>>> => {
+    return new I18nSchema(locales, schema);
+  };

package/src/schema/image.ts

@@ -0,0 +1,70 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema } from ".";
+import { FileSource, FILE_REF_PROP } from "../source/file";
+import { SourcePath } from "../val";
+
+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(src: Src): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  match(src: Src): boolean {
+    // TODO:
+    return true;
+  }
+
+  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 convertImageSource = (
+  src: FileSource<ImageMetadata>
+): { url: string; metadata?: ImageMetadata } => {
+  // TODO: /public should be configurable
+  return {
+    url:
+      src[FILE_REF_PROP].slice("/public".length) +
+      `?sha256=${src.metadata?.sha256}`,
+    metadata: src.metadata,
+  };
+};

package/src/schema/index.ts

@@ -0,0 +1,46 @@
+import { SelectorSource } from "../selector";
+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 { SerializedLiteralSchema } from "./literal";
+import { SerializedNumberSchema } from "./number";
+import { SerializedObjectSchema } from "./object";
+import { SerializedOneOfSchema } from "./oneOf";
+import { SerializedRichTextSchema } from "./richtext";
+import { SerializedStringSchema } from "./string";
+import { SerializedUnionSchema } from "./union";
+
+export type SerializedSchema =
+  | SerializedStringSchema
+  | SerializedLiteralSchema
+  | SerializedBooleanSchema
+  | SerializedNumberSchema
+  | SerializedObjectSchema
+  | SerializedOneOfSchema
+  | SerializedArraySchema
+  | SerializedUnionSchema
+  | SerializedRichTextSchema
+  | SerializedImageSchema
+  | SerializedI18nSchema;
+
+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 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()");
+  }
+}
+
+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/literal.ts

@@ -0,0 +1,42 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+
+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(src: Src): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  match(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

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { Schema, SerializedSchema } from ".";
+import { SourcePath } from "../val";
+
+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(src: Src): false | Record<SourcePath, string[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  match(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);
+};