@valbuild/core 0.12.0 → 0.13.0

package/src/index.ts

@@ -0,0 +1,55 @@
+export { initVal } from "./initVal";
+export { fetchVal } from "./fetchVal";
+export type { InitVal } from "./initVal";
+export { Schema, type SerializedSchema } from "./schema";
+export type { ValModule, SerializedModule } from "./module";
+export type { SourceObject, SourcePrimitive, Source } from "./source";
+export type { FileSource } from "./source/file";
+export type { RemoteSource } from "./source/remote";
+export {
+  type Val,
+  type SerializedVal,
+  type ModuleId,
+  type ModulePath,
+  type SourcePath,
+} from "./val";
+export * as expr from "./expr/";
+export { FILE_REF_PROP } from "./source/file";
+export { VAL_EXTENSION } from "./source";
+export { derefPatch } from "./patch/deref";
+export {
+  type SelectorSource,
+  type SelectorOf,
+  GenericSelector,
+} from "./selector";
+import { getVal } from "./fetchVal";
+import {
+  getRawSource,
+  resolvePath,
+  splitModuleIdAndModulePath,
+} from "./module";
+import { getSchema } from "./selector";
+import { getValPath } from "./val";
+export type {
+  RichText,
+  TextNode,
+  ParagraphNode,
+  HeadingNode,
+  ImageNode,
+  ListItemNode,
+  ListNode,
+  RootNode,
+} from "./schema/richtext";
+import { convertImageSource } from "./schema/image";
+
+const Internal = {
+  convertImageSource,
+  getSchema,
+  getValPath,
+  getVal,
+  getRawSource,
+  resolvePath,
+  splitModuleIdAndModulePath,
+};
+
+export { Internal };

package/src/initSchema.ts

@@ -0,0 +1,45 @@
+import { F } from "ts-toolbelt";
+import { array } from "./schema/array";
+import { number } from "./schema/number";
+import { object } from "./schema/object";
+import { string } from "./schema/string";
+import { boolean } from "./schema/boolean";
+import { oneOf } from "./schema/oneOf";
+import { union } from "./schema/union";
+import { i18n, I18n } from "./schema/i18n";
+import { richtext } from "./schema/richtext";
+import { image } from "./schema/image";
+import { literal } from "./schema/literal";
+
+export type InitSchema = {
+  readonly string: typeof string;
+  readonly boolean: typeof boolean;
+  readonly array: typeof array;
+  readonly object: typeof object;
+  readonly number: typeof number;
+  readonly union: typeof union;
+  readonly oneOf: typeof oneOf;
+  readonly richtext: typeof richtext;
+  readonly image: typeof image;
+  readonly literal: typeof literal;
+};
+export type InitSchemaLocalized<Locales extends readonly string[]> = {
+  readonly i18n: I18n<Locales>;
+};
+export function initSchema<Locales extends readonly string[]>(
+  locales: F.Narrow<Locales>
+) {
+  return {
+    string,
+    boolean,
+    array,
+    object,
+    number,
+    union,
+    oneOf,
+    richtext,
+    image,
+    literal,
+    i18n: i18n(locales),
+  };
+}

package/src/initVal.ts

@@ -0,0 +1,96 @@
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-constraint */
+import { content } from "./module";
+import { i18n, I18n } from "./source/i18n";
+import { InitSchema, initSchema, InitSchemaLocalized } from "./initSchema";
+import { SelectorOf } from "./selector";
+import { getValPath as getPath, Val } from "./val";
+import { SelectorSource, GenericSelector } from "./selector";
+import { JsonOfSource } from "./val";
+import { fetchVal } from "./fetchVal";
+import { remote } from "./source/remote";
+import { file } from "./source/file";
+
+type ValConstructor = {
+  content: typeof content;
+  getPath: typeof getPath; // TODO: in the react initVal we should also add a key function here which returns the path for use as react keys
+  key: typeof getPath;
+  remote: typeof remote;
+  file: typeof file;
+};
+export type InitVal<Locales extends readonly string[] | undefined> = [
+  Locales
+] extends [readonly string[]]
+  ? {
+      val: ValConstructor & {
+        i18n: I18n<Locales>;
+      };
+      fetchVal<T extends SelectorSource>(
+        selector: T,
+        locale: Locales[number]
+      ): SelectorOf<T> extends GenericSelector<infer S>
+        ? Promise<Val<JsonOfSource<S>>>
+        : never;
+      s: InitSchema & InitSchemaLocalized<Locales>;
+    }
+  : {
+      val: ValConstructor;
+      fetchVal<T extends SelectorSource>(
+        selector: T
+      ): SelectorOf<T> extends GenericSelector<infer S>
+        ? Promise<Val<JsonOfSource<S>>>
+        : never;
+      s: InitSchema;
+    };
+
+type NarrowStrings<A> =
+  | (A extends [] ? [] : never)
+  | (A extends string ? A : never)
+  | {
+      [K in keyof A]: NarrowStrings<A[K]>;
+    };
+
+export const initVal = <
+  Locales extends readonly string[] | undefined
+>(options?: {
+  readonly locales?: NarrowStrings<{
+    readonly required: Locales;
+    readonly fallback: Locales extends readonly string[]
+      ? Locales[number]
+      : never;
+  }>;
+}): InitVal<Locales> => {
+  const locales = options?.locales;
+  const s = initSchema(locales?.required as readonly string[]);
+  if (locales?.required) {
+    console.error("Locales / i18n currently not implemented");
+    return {
+      val: {
+        content,
+        i18n,
+        remote,
+        getPath,
+        key: getPath,
+        file,
+      },
+      fetchVal: fetchVal,
+      s,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any;
+  }
+  return {
+    val: {
+      content,
+      remote,
+      getPath,
+      key: getPath,
+      file,
+    },
+    fetchVal: fetchVal,
+    s: {
+      ...s,
+      i18n: undefined,
+    },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any;
+};

package/src/module.test.ts

@@ -0,0 +1,170 @@
+import {
+  resolvePath as resolveAtPath,
+  getSourceAtPath,
+  parsePath,
+  splitModuleIdAndModulePath,
+} from "./module";
+import { SchemaTypeOf } from "./schema";
+import { array } from "./schema/array";
+import { i18n as initI18nSchema } from "./schema/i18n";
+import { i18n as initI18nSource } from "./source/i18n";
+import { number } from "./schema/number";
+import { object } from "./schema/object";
+import { string, StringSchema } from "./schema/string";
+import { union } from "./schema/union";
+import { SourceOrExpr } from "./selector";
+import { newSelectorProxy } from "./selector/SelectorProxy";
+import { ModulePath, SourcePath } from "./val";
+import { literal } from "./schema/literal";
+
+const i18n = initI18nSchema(["en_US", "nb_NO"] as const);
+const val = {
+  i18n: initI18nSource(["en_US", "nb_NO"] as const),
+};
+describe("module", () => {
+  test("parse path", () => {
+    expect(parsePath('"foo"."bar".1."zoo"' as ModulePath)).toStrictEqual([
+      "foo",
+      "bar",
+      "1",
+      "zoo",
+    ]);
+
+    expect(parsePath('"foo"."bar".1."z\\"oo"' as ModulePath)).toStrictEqual([
+      "foo",
+      "bar",
+      "1",
+      'z"oo',
+    ]);
+
+    expect(parsePath('"foo"."b.ar".1."z\\"oo"' as ModulePath)).toStrictEqual([
+      "foo",
+      "b.ar",
+      "1",
+      'z"oo',
+    ]);
+  });
+
+  test("getSourceAtPath: basic selector", () => {
+    const [, modulePath] = splitModuleIdAndModulePath(
+      '/app."foo"."bar".1."zoo"' as SourcePath
+    );
+    expect(modulePath).toStrictEqual('"foo"."bar".1."zoo"');
+    const resolvedModuleAtPath = getSourceAtPath(
+      modulePath,
+      newSelectorProxy({
+        foo: {
+          bar: [{ zoo: "zoo1" }, { zoo: "zoo2" }],
+        },
+      })
+    );
+    expect(resolvedModuleAtPath[SourceOrExpr]).toStrictEqual("zoo2");
+  });
+
+  test("getSourceAtPath: basic source", () => {
+    const resolvedModuleAtPath = getSourceAtPath(
+      '"foo"."bar".1."zoo"' as ModulePath,
+      {
+        foo: {
+          bar: [{ zoo: "zoo1" }, { zoo: "zoo2" }],
+        },
+      }
+    );
+    expect(resolvedModuleAtPath).toStrictEqual("zoo2");
+  });
+
+  test("getSourceAtPath: with dots and escaped quotes", () => {
+    const resolvedModuleAtPath = getSourceAtPath(
+      '"foo"."b.ar".1."z\\"oo"' as ModulePath,
+      newSelectorProxy({
+        foo: {
+          "b.ar": [{ 'z"oo': "zoo1" }, { 'z"oo': "zoo2" }],
+        },
+      })
+    );
+    expect(resolvedModuleAtPath[SourceOrExpr]).toStrictEqual("zoo2");
+  });
+
+  test("getSchemaAtPath: array & object", () => {
+    const basicSchema = array(
+      object({
+        foo: array(object({ bar: string() })),
+        zoo: number(),
+      })
+    );
+    const { schema, source } = resolveAtPath(
+      '0."foo".0."bar"' as ModulePath,
+      [
+        {
+          foo: [
+            {
+              bar: "bar1",
+            },
+          ],
+          zoo: 1,
+        },
+      ] as SchemaTypeOf<typeof basicSchema>,
+      basicSchema
+    );
+    expect(schema).toBeInstanceOf(StringSchema);
+    expect(source).toStrictEqual("bar1");
+  });
+
+  test("getSchemaAtPath: i18n", () => {
+    const basicSchema = array(
+      object({
+        foo: i18n(array(object({ bar: string() }))),
+        zoo: number(),
+      })
+    );
+    const res = resolveAtPath(
+      '0."foo"."nb_NO".0."bar"' as ModulePath,
+      [
+        {
+          foo: val.i18n({
+            en_US: [
+              {
+                bar: "dive",
+              },
+            ],
+            nb_NO: [
+              {
+                bar: "brun",
+              },
+            ],
+          }),
+          zoo: 1,
+        },
+      ] as SchemaTypeOf<typeof basicSchema>,
+      basicSchema.serialize()
+    );
+    expect(res.schema).toStrictEqual(string().serialize());
+    expect(res.source).toStrictEqual("brun");
+  });
+
+  test("getSchemaAtPath: union", () => {
+    const basicSchema = array(
+      object({
+        foo: union(
+          "type",
+          object({ type: literal("test1"), bar: object({ zoo: string() }) }),
+          object({ type: literal("test2"), bar: object({ zoo: number() }) })
+        ),
+      })
+    );
+    const res = resolveAtPath(
+      '0."foo"."bar"."zoo"' as ModulePath,
+      [
+        {
+          foo: {
+            type: "test2",
+            bar: { zoo: 1 },
+          },
+        },
+      ] as SchemaTypeOf<typeof basicSchema>,
+      basicSchema.serialize()
+    );
+    expect(res.schema).toStrictEqual(number().serialize());
+    expect(res.source).toStrictEqual(1);
+  });
+});

package/src/module.ts

@@ -0,0 +1,333 @@
+import { Schema, SchemaTypeOf, SerializedSchema } from "./schema";
+import { ObjectSchema, SerializedObjectSchema } from "./schema/object";
+import {
+  GenericSelector,
+  SelectorOf,
+  SelectorSource,
+  SourceOrExpr,
+} from "./selector";
+import { Source, SourceArray } from "./source";
+import { newSelectorProxy } from "./selector/SelectorProxy";
+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 {
+  RichText,
+  RichTextSchema,
+  SerializedRichTextSchema,
+} from "./schema/richtext";
+import {
+  ImageMetadata,
+  ImageSchema,
+  SerializedImageSchema,
+} from "./schema/image";
+import { FileSource } from "./source/file";
+
+const brand = Symbol("ValModule");
+export type ValModule<T extends SelectorSource> = SelectorOf<T> &
+  ValModuleBrand;
+
+export type ValModuleBrand = {
+  [brand]: "ValModule";
+};
+
+export type TypeOfValModule<T extends ValModule<SelectorSource>> =
+  T extends GenericSelector<infer S> ? S : never;
+
+export function content<T extends Schema<SelectorSource>>(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  id: string,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  schema: T,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  source: SchemaTypeOf<T>
+): ValModule<SchemaTypeOf<T>> {
+  return newSelectorProxy(source, id as SourcePath, schema);
+}
+
+export function getRawSource(valModule: ValModule<SelectorSource>): Source {
+  const sourceOrExpr = valModule[SourceOrExpr];
+  if (sourceOrExpr instanceof Expr) {
+    throw Error("Cannot get raw source of an Expr");
+  }
+  const source = sourceOrExpr;
+  return source;
+}
+
+export function splitModuleIdAndModulePath(
+  path: SourcePath
+): [moduleId: ModuleId, path: ModulePath] {
+  return [
+    path.slice(0, path.indexOf(".")) as ModuleId,
+    path.slice(path.indexOf(".") + 1) as ModulePath,
+  ];
+}
+
+export function getSourceAtPath(
+  modulePath: ModulePath,
+  valModule: ValModule<SelectorSource> | Source
+) {
+  const parts = parsePath(modulePath);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let current: any = valModule;
+  for (const part of parts) {
+    if (typeof current !== "object") {
+      throw Error(`Invalid path: ${part} is not an object`);
+    }
+    current = current[part];
+  }
+  return current;
+}
+
+function isObjectSchema(
+  schema: Schema<SelectorSource> | SerializedSchema
+): schema is
+  | ObjectSchema<{ [key: string]: Schema<SelectorSource> }>
+  | SerializedObjectSchema {
+  return (
+    schema instanceof ObjectSchema ||
+    (typeof schema === "object" && "type" in schema && schema.type === "object")
+  );
+}
+
+function isArraySchema(
+  schema: Schema<SelectorSource> | SerializedSchema
+): schema is ArraySchema<Schema<SelectorSource>> | SerializedArraySchema {
+  return (
+    schema instanceof ArraySchema ||
+    (typeof schema === "object" && "type" in schema && schema.type === "array")
+  );
+}
+
+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
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+): schema is UnionSchema<string, any> | SerializedUnionSchema {
+  return (
+    schema instanceof UnionSchema ||
+    (typeof schema === "object" && "type" in schema && schema.type === "union")
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function isRichTextSchema(
+  schema: Schema<SelectorSource> | SerializedSchema
+): schema is
+  | Schema<RichText> // TODO: RichTextSchema
+  | SerializedRichTextSchema {
+  return (
+    schema instanceof RichTextSchema ||
+    (typeof schema === "object" &&
+      "type" in schema &&
+      schema.type === "richtext")
+  );
+}
+
+function isImageSchema(
+  schema: Schema<SelectorSource> | SerializedSchema
+): schema is
+  | ImageSchema<FileSource<ImageMetadata> | null>
+  | SerializedImageSchema {
+  return (
+    schema instanceof ImageSchema ||
+    (typeof schema === "object" && "type" in schema && schema.type === "image")
+  );
+}
+
+// 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")
+  );
+}
+
+export function resolvePath(
+  path: ModulePath,
+  valModule: ValModule<SelectorSource> | Source,
+  schema: Schema<SelectorSource> | SerializedSchema
+) {
+  const parts = parsePath(path);
+  const origParts = [...parts];
+  let resolvedSchema = schema;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let resolvedSource: any /* TODO: any */ = valModule;
+  while (parts.length > 0) {
+    const part = parts.shift();
+    if (part === undefined) {
+      throw Error("Unexpected undefined part");
+    }
+    if (isArraySchema(resolvedSchema)) {
+      if (Number.isNaN(Number(part))) {
+        throw Error(
+          `Invalid path: array schema ${resolvedSchema} must have ${part} a number as path`
+        );
+      }
+      if (
+        typeof resolvedSource !== "object" &&
+        !Array.isArray(resolvedSource)
+      ) {
+        throw Error(
+          `Schema type error: expected source to be type of array, but got ${typeof resolvedSource}`
+        );
+      }
+      if (!resolvedSource[part]) {
+        throw Error(
+          `Invalid path: array source (length: ${resolvedSource?.length}) did not have index ${part} from path: ${path}`
+        );
+      }
+      resolvedSource = resolvedSource[part];
+      resolvedSchema = resolvedSchema.item;
+    } else if (isObjectSchema(resolvedSchema)) {
+      if (typeof resolvedSource !== "object") {
+        throw Error(
+          `Schema type error: expected source to be type of object, but got ${typeof resolvedSource}`
+        );
+      }
+
+      if (!resolvedSource[part]) {
+        throw Error(
+          `Invalid path: object source did not have key ${part} from path: ${path}`
+        );
+      }
+      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 (isImageSchema(resolvedSchema)) {
+      return {
+        path: origParts
+          .slice(0, origParts.length - parts.length - 1)
+          .map((p) => JSON.stringify(p))
+          .join("."), // TODO: create a function generate path from parts (not sure if this always works)
+        schema: resolvedSchema,
+        source: resolvedSource,
+      };
+    } else if (isUnionSchema(resolvedSchema)) {
+      const key = resolvedSchema.key;
+      const keyValue = resolvedSource[key];
+      if (!keyValue) {
+        throw Error(
+          `Invalid path: union source ${resolvedSchema} did not have required key ${key} in path: ${path}`
+        );
+      }
+      const schemaOfUnionKey = resolvedSchema.items.find(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (child: any) => child?.items?.[key]?.value === keyValue
+      );
+      if (!schemaOfUnionKey) {
+        throw Error(
+          `Invalid path: union schema ${resolvedSchema} did not have a child object with ${key} of value ${keyValue} in path: ${path}`
+        );
+      }
+      resolvedSchema = schemaOfUnionKey.items[part];
+      resolvedSource = resolvedSource[part];
+    } else if (isRichTextSchema(resolvedSchema)) {
+      return {
+        path: origParts
+          .slice(0, origParts.length - parts.length - 1)
+          .map((p) => JSON.stringify(p))
+          .join("."), // TODO: create a function generate path from parts (not sure if this always works)
+        schema: resolvedSchema,
+        source: resolvedSource,
+      };
+    } else {
+      throw Error(
+        `Invalid path: ${part} resolved to an unexpected schema ${JSON.stringify(
+          resolvedSchema
+        )}`
+      );
+    }
+  }
+  if (parts.length > 0) {
+    throw Error(`Invalid path: ${parts.join(".")} is not a valid path`);
+  }
+  return {
+    path,
+    schema: resolvedSchema,
+    source: resolvedSource,
+  };
+}
+
+export function parsePath(input: ModulePath) {
+  const result = [];
+  let i = 0;
+
+  while (i < input.length) {
+    let part = "";
+
+    if (input[i] === '"') {
+      // Parse a quoted string
+      i++;
+      while (i < input.length && input[i] !== '"') {
+        if (input[i] === "\\" && input[i + 1] === '"') {
+          // Handle escaped double quotes
+          part += '"';
+          i++;
+        } else {
+          part += input[i];
+        }
+        i++;
+      }
+      if (input[i] !== '"') {
+        throw new Error(
+          `Invalid input (${JSON.stringify(
+            input
+          )}): Missing closing double quote: ${
+            input[i] ?? "at end of string"
+          } (char: ${i}; length: ${input.length})`
+        );
+      }
+    } else {
+      // Parse a regular string
+      while (i < input.length && input[i] !== ".") {
+        part += input[i];
+        i++;
+      }
+    }
+
+    if (part !== "") {
+      result.push(part);
+    }
+
+    i++;
+  }
+
+  return result;
+}
+
+export type SerializedModule = {
+  source: Json;
+  schema: SerializedSchema;
+  path: SourcePath;
+};