@valbuild/core 0.26.0 → 0.28.0

package/src/patch/parse.ts

@@ -1,202 +0,0 @@
-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 "file":
-      return pipe(
-        path,
-        result.mapErr(
-          (error: string): array.NonEmptyArray<StaticPatchIssue> => [
-            createIssueAtPath(["path"])(error),
-          ]
-        ),
-        result.map((path: string[]) => ({
-          op: operation.op,
-          path,
-          filePath: operation.filePath,
-          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

@@ -1,49 +0,0 @@
-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);
-    }
-    case "file": {
-      return result.err(new PatchError("Cannot apply a file patch here"));
-    }
-  }
-}
-
-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

@@ -1,74 +0,0 @@
-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);
-}
-
-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));
-}
-
-export function sourceToPatchPath(sourcePath: SourcePath) {
-  const [, modulePath] = splitModuleIdAndModulePath(sourcePath);
-  return modulePath.split(".").map((p) => JSON.parse(p).toString());
-}

package/src/schema/array.ts

@@ -1,93 +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 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(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;
-  }
-
-  assert(src: SchemaTypeOf<T>[]): boolean {
-    if (this.opt && (src === null || src === undefined)) {
-      return true;
-    }
-    if (!src) {
-      return false;
-    }
-
-    for (const item of src) {
-      if (!this.item.assert(item)) {
-        return false;
-      }
-    }
-    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

@@ -1,49 +0,0 @@
-/* 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";
-  opt: boolean;
-};
-
-export class BooleanSchema<Src extends boolean | null> extends Schema<Src> {
-  constructor(readonly opt: boolean = false) {
-    super();
-  }
-  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;
-  }
-
-  assert(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/future/i18n.ts

@@ -1,69 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-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";
-  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(
-    path: SourcePath,
-    src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>
-  ): ValidationErrors {
-    throw new Error("Method not implemented.");
-  }
-
-  assert(
-    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 {
-    throw new Error("Method not implemented.");
-
-    // 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/future/oneOf.ts

@@ -1,63 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-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";
-  selector: SourcePath;
-  opt: boolean;
-};
-
-type OneOfSelector<Sel extends GenericSelector<SourceArray>> =
-  Sel extends GenericSelector<infer S>
-    ? S extends (infer IS)[]
-      ? IS extends Source
-        ? GenericSelector<IS>
-        : never
-      : never
-    : never;
-
-export class OneOfSchema<
-  Sel extends GenericSelector<SourceArray>
-> extends Schema<OneOfSelector<Sel>> {
-  constructor(readonly selector: Sel, readonly opt: boolean = false) {
-    super();
-  }
-  validate(path: SourcePath, src: OneOfSelector<Sel>): ValidationErrors {
-    throw new Error("Method not implemented.");
-  }
-  assert(src: OneOfSelector<Sel>): boolean {
-    throw new Error("Method not implemented.");
-  }
-  optional(): Schema<OneOfSelector<Sel> | null> {
-    return new OneOfSchema(this.selector, true);
-  }
-
-  serialize(): SerializedSchema {
-    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,
-    // };
-  }
-}
-
-export const oneOf = <
-  Src extends GenericSelector<SourceArray> & 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<OneOfSelector<Src>> => {
-  return new OneOfSchema(valModule);
-};