akanjs 0.0.1 → 2.0.0-beta.0

package/base/base.ts

@@ -0,0 +1,194 @@
+import type { Cls } from ".";
+import { Float, Int } from "./primitiveRegistry";
+
+class EnumPrototype {}
+export type EnumInstance<RefName extends string = string, T = string | number> = Cls<
+  { refName: RefName; value: T },
+  {
+    refName: RefName;
+    type: StringConstructor | typeof Int | typeof Float;
+    values: readonly T[];
+    valueMap: Map<T, number>;
+    has: (value: T) => boolean;
+    indexOf: (value: T) => number;
+    find: (callback: (value: T, index: number, array: readonly T[]) => boolean) => T;
+    findIndex: (callback: (value: T, index: number, array: readonly T[]) => boolean) => number;
+    filter: (callback: (value: T, index: number, array: readonly T[]) => boolean) => T[];
+    map: <R>(callback: (value: T, index: number, array: readonly T[]) => R) => R[];
+    forEach: (callback: (value: T, index: number, array: readonly T[]) => void) => void;
+  }
+>;
+
+/** Returns true when a class was created by `enumOf`. */
+export const isEnum = (enumRef: Cls) => Object.getPrototypeOf(Object.getPrototypeOf(enumRef) ?? {}) === EnumPrototype;
+
+/** Creates a typed scalar enum class from a readonly list of string or number values. */
+export const enumOf = <RefName extends string, T = string | number>(
+  refName: RefName,
+  values: readonly T[],
+): EnumInstance<RefName, T> => {
+  const valueMap = new Map(values.map((value, idx) => [value, idx] as [T, number]));
+  const firstValue = values.at(0) as string | number | undefined;
+  if (firstValue === undefined) throw new Error("Enum values are empty");
+  const type =
+    typeof firstValue === "string"
+      ? String
+      : (values as readonly number[]).every((value: number) => value % 1 === 0)
+        ? Int
+        : Float;
+  class Enum extends EnumPrototype {
+    static readonly values = values;
+    static readonly valueMap = valueMap;
+    static readonly type = type;
+    static has(value: T): boolean {
+      return Enum.valueMap.has(value);
+    }
+    static indexOf(value: T): number {
+      const idx = Enum.valueMap.get(value);
+      if (idx === undefined) throw new Error(`Value ${value} is not in enum`);
+      return idx;
+    }
+    static find(callback: (value: T, index: number, array: readonly T[]) => boolean): T {
+      const val = Enum.values.find(callback);
+      if (val === undefined) throw new Error(`Value not found in enum`);
+      return val;
+    }
+    static findIndex(callback: (value: T, index: number, array: readonly T[]) => boolean): number {
+      const idx = Enum.values.findIndex(callback);
+      if (idx === -1) throw new Error(`Value not found in enum`);
+      return idx;
+    }
+    static filter(callback: (value: T, index: number, array: readonly T[]) => boolean): T[] {
+      return Enum.values.filter(callback);
+    }
+    static map<R>(callback: (value: T, index: number, array: readonly T[]) => R): R[] {
+      return Enum.values.map(callback);
+    }
+    static forEach(callback: (value: T, index: number, array: readonly T[]) => void): void {
+      Enum.values.forEach(callback);
+    }
+    static readonly refName = refName;
+    readonly refName = refName;
+    declare readonly value: T;
+  }
+  return Enum;
+};
+
+/** Id-keyed list helper used for light model collections and immutable-style list updates. */
+export class DataList<Light extends { id: string }> {
+  
+  #idMap: Map<string, number>;
+  length: number;
+  values: Light[];
+  constructor(data: Light[] | DataList<Light> = []) {
+    const values = Array.isArray(data) ? data : data.values;
+    this.values = [];
+    this.#idMap = new Map();
+    values.forEach((value) => {
+      const idx = this.#idMap.get(value.id);
+      if (idx === undefined) {
+        this.#idMap.set(value.id, this.values.length);
+        this.values.push(value);
+      } else this.values[idx] = value;
+    });
+    this.length = this.values.length;
+  }
+  indexOf(id: string) {
+    const idx = this.#idMap.get(id);
+    if (idx === undefined) throw new Error(`Value ${id} is not in list`);
+    return idx;
+  }
+  set(value: Light) {
+    const idx = this.#idMap.get(value.id);
+    if (idx !== undefined) this.values = [...this.values.slice(0, idx), value, ...this.values.slice(idx + 1)];
+    else {
+      this.#idMap.set(value.id, this.length);
+      this.values = [...this.values, value];
+      this.length++;
+    }
+    return this;
+  }
+  delete(id: string) {
+    const idx = this.#idMap.get(id);
+    if (idx === undefined) return this;
+    this.#idMap.delete(id);
+    this.values.splice(idx, 1);
+    this.values.slice(idx).forEach((value, i) => {
+      this.#idMap.set(value.id, i + idx);
+    });
+    this.length--;
+    return this;
+  }
+  get(id: string) {
+    const idx = this.#idMap.get(id);
+    if (idx === undefined) return undefined;
+    return this.values[idx];
+  }
+  at(idx: number) {
+    return this.values.at(idx);
+  }
+  pickAt(idx: number) {
+    const value = this.values.at(idx);
+    if (value === undefined) throw new Error(`Value at ${idx} is undefined`);
+    return value;
+  }
+  pick(id: string) {
+    return this.values[this.indexOf(id)];
+  }
+  has(id: string) {
+    return this.#idMap.has(id);
+  }
+  find(fn: (value: Light, idx: number) => boolean) {
+    const val = this.values.find(fn);
+    return val;
+  }
+  findIndex(fn: (value: Light, idx: number) => boolean) {
+    const val = this.values.findIndex(fn);
+    return val;
+  }
+  some(fn: (value: Light, idx: number) => boolean) {
+    return this.values.some(fn);
+  }
+  every(fn: (value: Light, idx: number) => boolean) {
+    return this.values.every(fn);
+  }
+  forEach(fn: (value: Light, idx: number) => void) {
+    this.values.forEach(fn);
+  }
+  map<T>(fn: (value: Light, idx: number) => T) {
+    return this.values.map(fn);
+  }
+  flatMap<T>(fn: (value: Light, idx: number, array: Light[]) => T | readonly T[]) {
+    return this.values.flatMap(fn);
+  }
+  sort(fn: (a: Light, b: Light) => number) {
+    return new DataList(this.values.sort(fn));
+  }
+  filter(fn: (value: Light, idx: number) => boolean) {
+    return new DataList(this.values.filter(fn));
+  }
+  reduce<T>(fn: (acc: T, value: Light, idx: number) => T, initialValue: T) {
+    return this.values.reduce(fn, initialValue);
+  }
+  slice(start: number, end = this.length) {
+    return new DataList(this.values.slice(start, end));
+  }
+  save() {
+    return new DataList(this);
+  }
+  [Symbol.iterator]() {
+    return this.values[Symbol.iterator]();
+  }
+}
+
+export const logo = `
+     _    _                  _     
+    / \\  | | ____ _ _ __    (_)___ 
+   / _ \\ | |/ / _' | '_ \\   | / __|
+  / ___ \\|   < (_| | | | |_ | \\__ \\
+ /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/
+                          |__/      
+? See more details on docs  https://www.akanjs.com/docs
+★ Star Akanjs on GitHub     https://github.com/akan-team/akanjs
+
+`;

package/base/baseEnv.ts

@@ -0,0 +1,162 @@
+type ProcessEnvLike = { env?: Record<string, string | undefined> };
+
+const globalWithProcess = globalThis as unknown as { process?: ProcessEnvLike };
+
+globalWithProcess.process ??= {};
+globalWithProcess.process.env ??= {};
+
+export type Environment = "testing" | "debug" | "develop" | "main" | "local";
+export type DatabaseMode = "single" | "multiple" | "cluster";
+export interface BaseEnv {
+  repoName: string;
+  serveDomain: string;
+  appName: string;
+  environment: Environment;
+  operationMode: "local" | "edge" | "cloud" | "module";
+  tunnelUsername: string;
+  tunnelPassword: string;
+  databaseMode?: DatabaseMode;
+}
+export type BackendEnv = BaseEnv & {
+  hostname?: string | null;
+  port?: number;
+  database?: {
+    mode?: DatabaseMode;
+    driver?: "sqlite" | "libsql" | "postgres";
+    sqlite?: {
+      filePath?: string;
+      journalMode?: string;
+      busyTimeoutMs?: number;
+      synchronous?: string;
+      foreignKeys?: boolean;
+      cacheSize?: number;
+      tempStore?: string;
+    };
+    libsql?: {
+      url?: string;
+      authToken?: string;
+    };
+    postgres?: {
+      url?: string;
+      host?: string;
+      port?: number;
+      database?: string;
+      user?: string;
+      password?: string;
+    };
+  };
+  solid?: {
+    filePath?: string;
+    journalMode?: string;
+    busyTimeoutMs?: number;
+    synchronous?: string;
+    cleanupIntervalMs?: number;
+    queuePollIntervalMs?: number;
+    queueLeaseMs?: number;
+  };
+  onCleanup?: () => Promise<void>;
+};
+
+export type ClientEnv = BaseEnv & {
+  side: "server" | "client";
+  renderMode: "ssr" | "csr";
+  websocket: boolean;
+  clientHost: string;
+  clientPort: number;
+  clientHttpProtocol: "http:" | "https:";
+  clientHttpUri: string;
+  serverHost: string;
+  serverPort: number;
+  serverHttpProtocol: "http:" | "https:";
+  serverHttpUri: string;
+  serverWsProtocol: "ws:" | "wss:";
+  serverWsUri: string;
+};
+
+let cachedEnv: ClientEnv | undefined;
+
+/** Reads and caches Akan runtime environment values from process/browser environment settings. */
+export const getEnv = (): ClientEnv => {
+  if (cachedEnv) return cachedEnv;
+  const appName = process.env.AKAN_PUBLIC_APP_NAME ?? "unknown";
+  const repoName = process.env.AKAN_PUBLIC_REPO_NAME ?? "unknown";
+  const serveDomain = process.env.AKAN_PUBLIC_SERVE_DOMAIN ?? "unknown";
+  if (appName === "unknown") throw new Error("environment variable AKAN_PUBLIC_APP_NAME is required");
+  if (repoName === "unknown") throw new Error("environment variable AKAN_PUBLIC_REPO_NAME is required");
+  if (serveDomain === "unknown") throw new Error("environment variable AKAN_PUBLIC_SERVE_DOMAIN is required");
+  const environment = (process.env.AKAN_PUBLIC_ENV ?? "debug") as BaseEnv["environment"];
+  const operationMode = (process.env.AKAN_PUBLIC_OPERATION_MODE ?? "cloud") as BaseEnv["operationMode"];
+  const tunnelUsername = process.env.SSH_TUNNEL_USERNAME ?? "root";
+  const tunnelPassword = process.env.SSH_TUNNEL_PASSWORD ?? repoName;
+  const baseEnv: BaseEnv = {
+    repoName,
+    serveDomain,
+    appName,
+    environment,
+    operationMode,
+    tunnelUsername,
+    tunnelPassword,
+    databaseMode: process.env.AKAN_DATABASE_MODE as DatabaseMode | undefined,
+  } as const;
+  const side = typeof window === "undefined" ? "server" : "client";
+  const renderMode = (process.env.AKAN_PUBLIC_RENDER_ENV ?? "csr") as ClientEnv["renderMode"];
+  const clientHost =
+    process.env.AKAN_PUBLIC_CLIENT_HOST ??
+    (operationMode === "local" || side === "server" ? "localhost" : window.location.hostname);
+  const clientPort = parseInt(process.env.AKAN_PUBLIC_CLIENT_PORT ?? (operationMode === "local" ? "8282" : "443"));
+  const clientHttpProtocol =
+    side === "client"
+      ? (window.location.protocol as "http:" | "https:")
+      : clientHost === "localhost"
+        ? "http:"
+        : "https:";
+  const clientHttpUri = `${clientHttpProtocol}//${clientHost}${clientPort === 443 ? "" : `:${clientPort}`}`;
+  const serverHost =
+    process.env.SERVER_HOST ??
+    (operationMode === "local"
+      ? typeof window === "undefined"
+        ? "localhost"
+        : (window.location.host.split(":")[0] ?? "unknown")
+      : renderMode === "csr"
+        ? `${appName}-${environment}.${serveDomain}`
+        : side === "client"
+          ? (window.location.host.split(":")[0] ?? "unknown")
+          : "localhost");
+
+  const serverPort = parseInt(
+    process.env.AKAN_PUBLIC_SERVER_PORT ?? (operationMode === "local" || side === "server" ? "8282" : "443"),
+  );
+  const serverHttpProtocol: "http:" | "https:" =
+    (process.env.SERVER_HTTP_PROTOCOL as "http:" | "https:" | undefined) ??
+    (operationMode === "local"
+      ? side === "client"
+        ? (window.location.protocol as "http:" | "https:")
+        : ("http:" as const)
+      : renderMode === "csr"
+        ? ("https:" as const)
+        : side === "client"
+          ? (window.location.protocol as "http:" | "https:")
+          : ("http:" as const));
+  const serverHttpUri = `${serverHttpProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}/api`;
+  const serverWsProtocol = serverHttpProtocol === "http:" ? "ws:" : "wss:";
+  const serverWsUri = `${serverWsProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}`;
+
+  const env: ClientEnv = {
+    ...baseEnv,
+    side,
+    renderMode,
+    websocket: true,
+    clientHost,
+    clientPort,
+    clientHttpProtocol,
+    clientHttpUri,
+    serverHost,
+    serverPort,
+    serverHttpProtocol,
+    serverHttpUri,
+    serverWsProtocol,
+    serverWsUri,
+  } as const;
+  cachedEnv = env;
+  return env;
+};

package/base/index.ts

@@ -0,0 +1,6 @@
+export * from "./base";
+export * from "./baseEnv";
+export * from "./primitiveRegistry";
+export * from "./symbols";
+export * from "./types";
+export * from "./utils";

package/base/primitiveRegistry.ts

@@ -0,0 +1,342 @@
+import dayjsLib, { type Dayjs } from "dayjs";
+
+import type { Cls } from "./types";
+
+export type { Dayjs };
+
+/** Shared dayjs factory re-export used by Akan documents, services, stores, and UI. */
+export const dayjs = dayjsLib;
+
+/** Registry that maps Akan primitive scalar names to their runtime scalar classes. */
+export class PrimitiveRegistry {
+  static readonly #namePrimitiveMap = new Map<string, typeof PrimitiveScalar>();
+  static readonly #primitiveNameMap = new Map<typeof PrimitiveScalar, string>();
+  static register(scalar: typeof PrimitiveScalar, { overwrite = false } = {}) {
+    if (
+      !overwrite &&
+      (PrimitiveRegistry.#namePrimitiveMap.has(scalar.refName) || PrimitiveRegistry.#primitiveNameMap.has(scalar))
+    )
+      throw new Error(`Scalar ${scalar.refName} already registered`);
+    PrimitiveRegistry.#namePrimitiveMap.set(scalar.refName, scalar);
+    PrimitiveRegistry.#primitiveNameMap.set(scalar, scalar.refName);
+  }
+  static get(name: string): typeof PrimitiveScalar {
+    const scalar = PrimitiveRegistry.#namePrimitiveMap.get(name);
+    if (!scalar) throw new Error(`Scalar ${name} not found`);
+    return scalar;
+  }
+  static getName(scalar: typeof PrimitiveScalar): string {
+    const name = PrimitiveRegistry.#primitiveNameMap.get(scalar);
+    if (!name) throw new Error(`Scalar ${scalar} not found`);
+    return name;
+  }
+  static has(modelRef: Cls): boolean {
+    return PrimitiveRegistry.#primitiveNameMap.has(modelRef as typeof PrimitiveScalar);
+  }
+  static hasName(name: string): boolean {
+    return PrimitiveRegistry.#namePrimitiveMap.has(name);
+  }
+  static getNames(): string[] {
+    return [...PrimitiveRegistry.#namePrimitiveMap.keys()];
+  }
+  static getAll(): (typeof PrimitiveScalar)[] {
+    return [...PrimitiveRegistry.#namePrimitiveMap.values()];
+  }
+}
+
+export const PRIMITIVE_SERVER_VALUE = Symbol.for("PRIMITIVE_SERVER_VALUE");
+export const PRIMITIVE_CLIENT_VALUE = Symbol.for("PRIMITIVE_CLIENT_VALUE");
+export const PRIMITIVE_DEFAULT_VALUE = Symbol.for("PRIMITIVE_DEFAULT_VALUE");
+export const PRIMITIVE_EXAMPLE_VALUE = Symbol.for("PRIMITIVE_EXAMPLE_VALUE");
+export type PrimitiveValue = string | number | boolean | Dayjs | Date | null | undefined;
+export class PrimitiveScalar {
+  static refName: string;
+  static [PRIMITIVE_SERVER_VALUE]: unknown;
+  static [PRIMITIVE_CLIENT_VALUE]: unknown;
+  static [PRIMITIVE_DEFAULT_VALUE]: unknown = null;
+  static [PRIMITIVE_EXAMPLE_VALUE]: unknown = null;
+
+  static validate(value: PrimitiveValue): boolean {
+    return true;
+  }
+  static parseValue(value: PrimitiveValue): PrimitiveValue {
+    return value;
+  }
+  static serializeValue(value: PrimitiveValue): PrimitiveValue {
+    return value;
+  }
+  static _parse(
+    this: typeof PrimitiveScalar,
+    input: PrimitiveValue,
+    { optional = false }: { optional?: boolean } = {},
+  ): PrimitiveValue {
+    if (optional && (input === null || input === undefined)) return undefined;
+    
+    const value = this.parseValue(input);
+    
+    this._checkValue(value, { optional });
+    return value;
+  }
+  static _serialize(
+    this: typeof PrimitiveScalar,
+    value: PrimitiveValue,
+    { optional = false }: { optional?: boolean } = {},
+  ): PrimitiveValue {
+    
+    this._checkValue(value, { optional });
+    if (value === null || value === undefined) return undefined;
+    
+    return this.serializeValue(value);
+  }
+  static _checkValue(
+    this: typeof PrimitiveScalar,
+    value: PrimitiveValue,
+    { optional = false }: { optional?: boolean } = {},
+  ): void {
+    if (value === null || value === undefined) {
+      if (optional) return;
+      else throw new Error(`Required ${this.refName} value: ${value}`);
+    }
+    
+    if (!this.validate(value)) throw new Error(`Invalid ${this.refName} value: ${value}`);
+  }
+}
+
+/** Integer primitive scalar. Accepts safe integer numbers after parsing. */
+export class Int extends PrimitiveScalar {
+  static override refName: "Int" = "Int";
+  static override [PRIMITIVE_SERVER_VALUE]: number;
+  static override [PRIMITIVE_CLIENT_VALUE]: number;
+  static override [PRIMITIVE_DEFAULT_VALUE]: number = 0;
+  static override [PRIMITIVE_EXAMPLE_VALUE]: number = 0;
+
+  static override validate(value: string | number): boolean {
+    return typeof value === "number" && Number.isSafeInteger(value);
+  }
+  static override parseValue(input: string | number): number {
+    return Number(input);
+  }
+  static override serializeValue(value: number): number {
+    return value;
+  }
+}
+PrimitiveRegistry.register(Int);
+
+/** Floating point primitive scalar. Accepts finite numbers after parsing. */
+export class Float extends PrimitiveScalar {
+  static override refName: "Float" = "Float";
+  static override [PRIMITIVE_SERVER_VALUE]: number;
+  static override [PRIMITIVE_CLIENT_VALUE]: number;
+  static override [PRIMITIVE_DEFAULT_VALUE]: number = 0;
+  static override [PRIMITIVE_EXAMPLE_VALUE]: number = 0;
+
+  static override validate(value: string | number): boolean {
+    return typeof value === "number" && Number.isFinite(value);
+  }
+  static override parseValue(input: string | number): number {
+    return Number(input);
+  }
+  static override serializeValue(value: number): number {
+    return value;
+  }
+}
+PrimitiveRegistry.register(Float);
+
+/** 24-character hexadecimal id primitive used by Akan document and signal models. */
+export class ID extends PrimitiveScalar {
+  static override refName: "ID" = "ID";
+  static override [PRIMITIVE_SERVER_VALUE]: string;
+  static override [PRIMITIVE_CLIENT_VALUE]: string;
+  static override [PRIMITIVE_DEFAULT_VALUE]: string = "";
+  static override [PRIMITIVE_EXAMPLE_VALUE]: string = "1234567890abcdef12345678";
+
+  static override validate(value: string): boolean {
+    if (typeof value !== "string") return false;
+    return /^[0-9a-fA-F]{24}$/.test(value);
+  }
+  static override parseValue(input: string): string {
+    return String(input);
+  }
+  static override serializeValue(value: string): string {
+    return String(value);
+  }
+  static override _checkValue(value: PrimitiveValue, options: { optional?: boolean } = {}): void {
+    if (value === ID[PRIMITIVE_DEFAULT_VALUE]) return;
+    
+    super._checkValue(value, options);
+  }
+}
+PrimitiveRegistry.register(ID);
+
+/** Open object primitive for intentionally flexible payloads or metadata blobs. */
+export class Any extends PrimitiveScalar {
+  static override refName: "Any" = "Any";
+  static override [PRIMITIVE_DEFAULT_VALUE]: object | null = null;
+  static override [PRIMITIVE_EXAMPLE_VALUE]: object = {};
+}
+PrimitiveRegistry.register(Any);
+
+export class Upload extends PrimitiveScalar {
+  static override refName: "Upload" = "Upload";
+  static override [PRIMITIVE_SERVER_VALUE]: File;
+  static override [PRIMITIVE_CLIENT_VALUE]: File;
+  static override [PRIMITIVE_DEFAULT_VALUE]: File | null = null;
+  static override [PRIMITIVE_EXAMPLE_VALUE] = "FileUpload";
+  __TEMP_TYPE__: "Upload" = "Upload";
+}
+PrimitiveRegistry.register(Upload);
+
+declare global {
+  interface StringConstructor {
+    refName: "String";
+    [PRIMITIVE_SERVER_VALUE]: string;
+    [PRIMITIVE_CLIENT_VALUE]: string;
+    [PRIMITIVE_DEFAULT_VALUE]: string;
+    [PRIMITIVE_EXAMPLE_VALUE]: string;
+    validate(value: string): boolean;
+    parseValue(input: string): string;
+    serializeValue(value: string): string;
+    _parse(input: string): string;
+    _serialize(value: string): string;
+    _checkValue(value: string): void;
+  }
+  interface BooleanConstructor {
+    refName: "Boolean";
+    [PRIMITIVE_SERVER_VALUE]: boolean;
+    [PRIMITIVE_CLIENT_VALUE]: boolean;
+    [PRIMITIVE_DEFAULT_VALUE]: boolean;
+    [PRIMITIVE_EXAMPLE_VALUE]: boolean;
+    validate(value: boolean): boolean;
+    parseValue(input: boolean): boolean;
+    serializeValue(value: boolean): boolean;
+    _parse(input: boolean): boolean;
+    _serialize(value: boolean): boolean;
+    _checkValue(value: boolean): void;
+  }
+  interface DateConstructor {
+    refName: "Date";
+    [PRIMITIVE_SERVER_VALUE]: Dayjs;
+    [PRIMITIVE_CLIENT_VALUE]: Dayjs;
+    [PRIMITIVE_DEFAULT_VALUE]: Dayjs;
+    [PRIMITIVE_EXAMPLE_VALUE]: string;
+    validate(value: Date): boolean;
+    parseValue(input: Date): Dayjs;
+    serializeValue(value: Dayjs | Date): Date;
+    _parse(input: Date): Dayjs;
+    _serialize(value: Dayjs | Date): Date;
+    _checkValue(value: Date): void;
+  }
+}
+
+const scalarPrimitiveStatics = {
+  _parse(
+    this: typeof PrimitiveScalar,
+    input: PrimitiveValue,
+    { optional = false }: { optional?: boolean } = {},
+  ): PrimitiveValue {
+    if (optional && (input === null || input === undefined)) return undefined;
+    const value = this.parseValue(input);
+    this._checkValue(value, { optional });
+    return value;
+  },
+  _serialize(
+    this: typeof PrimitiveScalar,
+    value: PrimitiveValue,
+    { optional = false }: { optional?: boolean } = {},
+  ): PrimitiveValue {
+    if (optional && value === "") return undefined;
+    if (this.refName === "Date" && optional && typeof value === "string" && Number.isNaN(new Date(value).getTime()))
+      return undefined;
+    if (this.refName === "Date" && optional && value instanceof Date && Number.isNaN(value.getTime())) return undefined;
+    if (
+      optional &&
+      value &&
+      typeof value === "object" &&
+      "isValid" in value &&
+      !(value as { isValid: () => boolean }).isValid()
+    )
+      return undefined;
+    this._checkValue(value, { optional });
+    if (value === null || value === undefined) return undefined;
+    return this.serializeValue(value);
+  },
+  _checkValue(
+    this: typeof PrimitiveScalar,
+    value: PrimitiveValue,
+    { optional = false }: { optional?: boolean } = {},
+  ): void {
+    if (value === null || value === undefined) {
+      if (optional) return;
+      else throw new Error(`Required ${this.refName} value: ${value}`);
+    }
+    if (optional && value === "") return;
+    if (this.refName === "Date" && optional && typeof value === "string" && Number.isNaN(new Date(value).getTime()))
+      return;
+    if (this.refName === "Date" && optional && value instanceof Date && Number.isNaN(value.getTime())) return;
+    if (
+      optional &&
+      value &&
+      typeof value === "object" &&
+      "isValid" in value &&
+      !(value as { isValid: () => boolean }).isValid()
+    )
+      return;
+    if (!this.validate(value)) throw new Error(`Invalid ${this.refName} value: ${value}`);
+  },
+};
+
+Object.assign(String, scalarPrimitiveStatics, {
+  refName: "String",
+  [PRIMITIVE_DEFAULT_VALUE]: "",
+  [PRIMITIVE_EXAMPLE_VALUE]: "String",
+  validate(value: string) {
+    return typeof value === "string";
+  },
+  parseValue(input: string) {
+    return String(input);
+  },
+  serializeValue(value: string) {
+    return String(value);
+  },
+});
+PrimitiveRegistry.register(String);
+
+Object.assign(Boolean, {
+  ...scalarPrimitiveStatics,
+  refName: "Boolean",
+  [PRIMITIVE_DEFAULT_VALUE]: false,
+  [PRIMITIVE_EXAMPLE_VALUE]: true,
+  validate(value: boolean) {
+    return typeof value === "boolean";
+  },
+  parseValue(input: boolean) {
+    return Boolean(input);
+  },
+  serializeValue(value: boolean) {
+    return Boolean(value);
+  },
+});
+PrimitiveRegistry.register(Boolean);
+
+Object.assign(Date, {
+  ...scalarPrimitiveStatics,
+  refName: "Date",
+  [PRIMITIVE_DEFAULT_VALUE]: dayjs(new Date(-1)),
+  [PRIMITIVE_EXAMPLE_VALUE]: dayjs(new Date().toISOString()),
+  validate(value: Date | string | number) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime())) return false;
+    return true;
+  },
+  parseValue(input: Date | string | number | Dayjs) {
+    return dayjs(input);
+  },
+  serializeValue(value: Dayjs | Date | string | number) {
+    if (value instanceof Date) return value;
+    if (typeof value === "string" || typeof value === "number") return dayjs(value).toDate();
+    return value.toDate();
+  },
+});
+PrimitiveRegistry.register(Date);
+
+export type DefaultPrimitiveName = "String" | "Boolean" | "Date" | "Int" | "Float" | "ID" | "Any" | "Upload";