chore: initialize from frontend template 4dc033c

src/contracts/schema-registry.ts

@@ -0,0 +1,111 @@
+export type SchemaDefinition = Readonly<{
+  schemaId: string;
+  boundary:
+    | "route-params"
+    | "route-search"
+    | "route-search-api-request"
+    | "api-request"
+    | "api-response";
+  owner: string;
+  runtime: "zod";
+  schemaVersion?: number;
+  direction?: "REQUEST" | "RESPONSE";
+  unknownFieldPolicy?: "REJECT_UNKNOWN" | "STRIP_UNKNOWN";
+}>;
+
+export type RuntimeSchemaResult =
+  | Readonly<{ success: true; data: unknown }>
+  | Readonly<{
+      success: false;
+      issues: readonly Readonly<{ path: string; code: string }>[];
+    }>;
+
+export type RuntimeSchemaCodec = Readonly<{
+  schemaId: string;
+  parse(value: unknown): RuntimeSchemaResult;
+}>;
+
+export function composeRuntimeSchemaCodecs(
+  contributions: readonly Readonly<Record<string, RuntimeSchemaCodec>>[],
+): Readonly<Record<string, RuntimeSchemaCodec>> {
+  const result: Record<string, RuntimeSchemaCodec> = Object.create(null);
+  for (const contribution of contributions) {
+    for (const [registryId, codec] of Object.entries(contribution)) {
+      if (
+        registryId !== codec.schemaId ||
+        Object.hasOwn(result, registryId)
+      ) {
+        throw new TypeError(
+          `Invalid or duplicate runtime schema codec: ${registryId}`,
+        );
+      }
+      result[registryId] = codec;
+    }
+  }
+  return Object.freeze(result);
+}
+
+export function validateWithRuntimeSchemaRegistry(
+  schemaId: string,
+  value: unknown,
+  registry: Readonly<Record<string, RuntimeSchemaCodec>>,
+): RuntimeSchemaResult {
+  const codec = registry[schemaId];
+  if (!codec) {
+    return Object.freeze({
+      success: false,
+      issues: Object.freeze([
+        Object.freeze({ path: "", code: "SCHEMA_NOT_REGISTERED" }),
+      ]),
+    });
+  }
+  try {
+    return codec.parse(value);
+  } catch {
+    return Object.freeze({
+      success: false,
+      issues: Object.freeze([
+        Object.freeze({ path: "", code: "SCHEMA_EXECUTION_FAILED" }),
+      ]),
+    });
+  }
+}
+
+export function composeSchemaRegistry(
+  contributions: readonly Readonly<Record<string, SchemaDefinition>>[],
+): Readonly<Record<string, SchemaDefinition>> {
+  const result: Record<string, SchemaDefinition> = Object.create(null);
+  for (const contribution of contributions) {
+    for (const [registryId, definition] of Object.entries(contribution)) {
+      if (
+        registryId !== definition.schemaId ||
+        !definition.owner ||
+        (definition.schemaVersion !== undefined &&
+          (!Number.isSafeInteger(definition.schemaVersion) ||
+            definition.schemaVersion < 1)) ||
+        Object.hasOwn(result, registryId)
+      ) {
+        throw new TypeError(`Invalid or duplicate schema definition: ${registryId}`);
+      }
+      result[registryId] = definition;
+    }
+  }
+  return Object.freeze(result);
+}
+
+export const PLATFORM_SCHEMA_REGISTRY: Readonly<
+  Record<string, SchemaDefinition>
+> = Object.freeze({
+      none: Object.freeze({
+        schemaId: "none",
+        boundary: "route-params",
+        owner: "feature-frontend-routing-release-recovery-runtime",
+        runtime: "zod",
+      }),
+      NotFoundSplat: Object.freeze({
+        schemaId: "NotFoundSplat",
+        boundary: "route-params",
+        owner: "feature-frontend-routing-release-recovery-runtime",
+        runtime: "zod",
+      }),
+    });