@openclaw/nostr 2026.5.20 → 2026.5.22

package/node_modules/zod/src/v4/classic/tests/codec-examples.test.ts

@@ -0,0 +1,573 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+// ============================================================================
+// stringToNumber
+// ============================================================================
+
+const stringToNumber = () =>
+  z.codec(z.string(), z.number(), {
+    decode: (str) => Number.parseFloat(str),
+    encode: (num) => num.toString(),
+  });
+
+test("stringToNumber codec", () => {
+  const codec = stringToNumber();
+
+  // Test decode
+  expect(z.decode(codec, "42.5")).toBe(42.5);
+  expect(z.decode(codec, "0")).toBe(0);
+  expect(z.decode(codec, "-123.456")).toBe(-123.456);
+
+  // Test encode
+  expect(z.encode(codec, 42.5)).toBe("42.5");
+  expect(z.encode(codec, 0)).toBe("0");
+  expect(z.encode(codec, -123.456)).toBe("-123.456");
+
+  // Test round trip
+  const original = "3.14159";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe("3.14159");
+});
+
+// ============================================================================
+// stringToInt
+// ============================================================================
+
+const stringToInt = () =>
+  z.codec(z.string(), z.int(), {
+    decode: (str) => Number.parseInt(str, 10),
+    encode: (num) => num.toString(),
+  });
+
+test("stringToInt codec", () => {
+  const codec = stringToInt();
+
+  // Test decode
+  expect(z.decode(codec, "42")).toBe(42);
+  expect(z.decode(codec, "0")).toBe(0);
+  expect(z.decode(codec, "-123")).toBe(-123);
+
+  // Test encode
+  expect(z.encode(codec, 42)).toBe("42");
+  expect(z.encode(codec, 0)).toBe("0");
+  expect(z.encode(codec, -123)).toBe("-123");
+
+  // Test round trip
+  const original = "999";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe("999");
+});
+
+// ============================================================================
+// stringToBigInt
+// ============================================================================
+
+const stringToBigInt = () =>
+  z.codec(z.string(), z.bigint(), {
+    decode: (str) => BigInt(str),
+    encode: (bigint) => bigint.toString(),
+  });
+
+test("stringToBigInt codec", () => {
+  const codec = stringToBigInt();
+
+  // Test decode
+  expect(z.decode(codec, "123456789012345678901234567890")).toBe(123456789012345678901234567890n);
+  expect(z.decode(codec, "0")).toBe(0n);
+  expect(z.decode(codec, "-999")).toBe(-999n);
+
+  // Test encode
+  expect(z.encode(codec, 123456789012345678901234567890n)).toBe("123456789012345678901234567890");
+  expect(z.encode(codec, 0n)).toBe("0");
+  expect(z.encode(codec, -999n)).toBe("-999");
+
+  // Test round trip
+  const original = "987654321098765432109876543210";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe("987654321098765432109876543210");
+});
+
+// ============================================================================
+// numberToBigInt
+// ============================================================================
+
+const numberToBigInt = () =>
+  z.codec(z.int(), z.bigint(), {
+    decode: (num) => BigInt(num),
+    encode: (bigint) => Number(bigint),
+  });
+
+test("numberToBigInt codec", () => {
+  const codec = numberToBigInt();
+
+  // Test decode
+  expect(z.decode(codec, 42)).toBe(42n);
+  expect(z.decode(codec, 0)).toBe(0n);
+  expect(z.decode(codec, -123)).toBe(-123n);
+
+  // Test encode
+  expect(z.encode(codec, 42n)).toBe(42);
+  expect(z.encode(codec, 0n)).toBe(0);
+  expect(z.encode(codec, -123n)).toBe(-123);
+
+  // Test round trip
+  const original = 999;
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe(999);
+});
+
+// ============================================================================
+// isoDatetimeToDate
+// ============================================================================
+
+const isoDatetimeToDate = () =>
+  z.codec(z.iso.datetime(), z.date(), {
+    decode: (isoString) => new Date(isoString),
+    encode: (date) => date.toISOString(),
+  });
+
+test("isoDatetimeToDate codec", () => {
+  const codec = isoDatetimeToDate();
+
+  // Test decode
+  const decoded = z.decode(codec, "2024-01-15T10:30:00.000Z");
+  expect(decoded).toBeInstanceOf(Date);
+  expect(decoded.getTime()).toBe(1705314600000);
+
+  // Test encode
+  const date = new Date("2024-01-15T10:30:00.000Z");
+  expect(z.encode(codec, date)).toBe("2024-01-15T10:30:00.000Z");
+
+  // Test round trip
+  const original = "2024-12-25T15:45:30.123Z";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe("2024-12-25T15:45:30.123Z");
+});
+
+// ============================================================================
+// epochSecondsToDate
+// ============================================================================
+
+const epochSecondsToDate = () =>
+  z.codec(z.int().min(0), z.date(), {
+    decode: (seconds) => new Date(seconds * 1000),
+    encode: (date) => Math.floor(date.getTime() / 1000),
+  });
+
+test("epochSecondsToDate codec", () => {
+  const codec = epochSecondsToDate();
+
+  // Test decode
+  const decoded = z.decode(codec, 1705314600);
+  expect(decoded).toBeInstanceOf(Date);
+  expect(decoded.getTime()).toBe(1705314600000);
+
+  // Test encode
+  const date = new Date(1705314600000);
+  expect(z.encode(codec, date)).toBe(1705314600);
+
+  // Test round trip
+  const original = 1640995200; // 2022-01-01 00:00:00 UTC
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe(1640995200);
+});
+
+// ============================================================================
+// epochMillisToDate
+// ============================================================================
+
+const epochMillisToDate = () =>
+  z.codec(z.int().min(0), z.date(), {
+    decode: (millis) => new Date(millis),
+    encode: (date) => date.getTime(),
+  });
+
+test("epochMillisToDate codec", () => {
+  const codec = epochMillisToDate();
+
+  // Test decode
+  const decoded = z.decode(codec, 1705314600000);
+  expect(decoded).toBeInstanceOf(Date);
+  expect(decoded.getTime()).toBe(1705314600000);
+
+  // Test encode
+  const date = new Date(1705314600000);
+  expect(z.encode(codec, date)).toBe(1705314600000);
+
+  // Test round trip
+  const original = 1640995200123; // 2022-01-01 00:00:00.123 UTC
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe(1640995200123);
+});
+
+// ============================================================================
+// json
+// ============================================================================
+
+const jsonCodec = <T extends z.core.$ZodType>(schema: T) =>
+  z.codec(z.string(), schema, {
+    decode: (jsonString, ctx) => {
+      try {
+        return JSON.parse(jsonString);
+      } catch (err: any) {
+        ctx.issues.push({
+          code: "invalid_format",
+          format: "json",
+          input: jsonString,
+          message: err.message,
+        });
+        return z.NEVER;
+      }
+    },
+    encode: (value) => JSON.stringify(value),
+  });
+
+test("json codec", () => {
+  const codec = jsonCodec(z.object({ name: z.string(), age: z.number() }));
+
+  // Test decode
+  const decoded = z.decode(codec, '{"name":"Alice","age":30}');
+  expect(decoded).toEqual({ name: "Alice", age: 30 });
+
+  // Test encode
+  const encoded = z.encode(codec, { name: "Bob", age: 25 });
+  expect(encoded).toBe('{"name":"Bob","age":25}');
+
+  // Test round trip
+  const original = '{"name":"Charlie","age":35}';
+  const parsed = z.decode(codec, original);
+  const roundTrip = z.encode(codec, parsed);
+  expect(JSON.parse(roundTrip)).toEqual(JSON.parse(original));
+});
+
+// ============================================================================
+// utf8ToBytes
+// ============================================================================
+
+const utf8ToBytes = () =>
+  z.codec(z.string(), z.instanceof(Uint8Array), {
+    decode: (str) => new TextEncoder().encode(str),
+    encode: (bytes) => new TextDecoder().decode(bytes),
+  });
+
+test("utf8ToBytes codec", () => {
+  const codec = utf8ToBytes();
+
+  // Test decode
+  const decoded = z.decode(codec, "Hello, 世界!");
+  expect(decoded).toBeInstanceOf(Uint8Array);
+  expect(Array.from(decoded)).toEqual([72, 101, 108, 108, 111, 44, 32, 228, 184, 150, 231, 149, 140, 33]);
+
+  // Test encode
+  const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+  expect(z.encode(codec, bytes)).toBe("Hello");
+
+  // Test round trip
+  const original = "Hello, 世界! 🚀";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe(original);
+});
+
+// ============================================================================
+// bytesToUtf8
+// ============================================================================
+
+const bytesToUtf8 = () =>
+  z.codec(z.instanceof(Uint8Array), z.string(), {
+    decode: (bytes) => new TextDecoder().decode(bytes),
+    encode: (str) => new TextEncoder().encode(str),
+  });
+
+test("bytesToUtf8 codec", () => {
+  const codec = bytesToUtf8();
+
+  // Test decode
+  const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+  const decoded = z.decode(codec, bytes);
+  expect(decoded).toBe("Hello");
+
+  // Test encode
+  const encoded = z.encode(codec, "Hello, 世界!");
+  expect(encoded).toBeInstanceOf(Uint8Array);
+  expect(Array.from(encoded)).toEqual([72, 101, 108, 108, 111, 44, 32, 228, 184, 150, 231, 149, 140, 33]);
+
+  // Test round trip
+  const original = new Uint8Array([72, 101, 108, 108, 111, 44, 32, 228, 184, 150, 231, 149, 140, 33]);
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toEqual(original);
+});
+
+// ============================================================================
+// base64
+// ============================================================================
+
+const base64 = () =>
+  z.codec(z.base64(), z.instanceof(Uint8Array), {
+    decode: (base64String) => z.util.base64ToUint8Array(base64String),
+    encode: (bytes) => z.util.uint8ArrayToBase64(bytes),
+  });
+
+test("base64 codec", () => {
+  const codec = base64();
+
+  // Test decode
+  const decoded = z.decode(codec, "SGVsbG8=");
+  expect(decoded).toBeInstanceOf(Uint8Array);
+  expect(Array.from(decoded)).toEqual([72, 101, 108, 108, 111]);
+
+  // Test encode
+  const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+  expect(z.encode(codec, bytes)).toBe("SGVsbG8=");
+
+  // Test round trip
+  const original = "SGVsbG8gV29ybGQh";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe(original);
+});
+
+// ============================================================================
+// base64urlToBytes
+// ============================================================================
+
+const base64urlToBytes = () =>
+  z.codec(z.base64url(), z.instanceof(Uint8Array), {
+    decode: (base64urlString) => z.util.base64urlToUint8Array(base64urlString),
+    encode: (bytes) => z.util.uint8ArrayToBase64url(bytes),
+  });
+
+test("base64urlToBytes codec", () => {
+  const codec = base64urlToBytes();
+
+  // Test decode
+  const decoded = z.decode(codec, "SGVsbG8");
+  expect(decoded).toBeInstanceOf(Uint8Array);
+  expect(Array.from(decoded)).toEqual([72, 101, 108, 108, 111]);
+
+  // Test encode
+  const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+  expect(z.encode(codec, bytes)).toBe("SGVsbG8");
+
+  // Test round trip with padding case
+  const original = "SGVsbG9Xb3JsZA";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe(original);
+});
+
+// ============================================================================
+// hexToBytes
+// ============================================================================
+
+const hexToBytes = () =>
+  z.codec(z.hex(), z.instanceof(Uint8Array), {
+    decode: (hexString) => z.util.hexToUint8Array(hexString),
+    encode: (bytes) => z.util.uint8ArrayToHex(bytes),
+  });
+
+test("hexToBytes codec", () => {
+  const codec = hexToBytes();
+
+  // Test decode
+  const decoded = z.decode(codec, "48656c6c6f");
+  expect(decoded).toBeInstanceOf(Uint8Array);
+  expect(Array.from(decoded)).toEqual([72, 101, 108, 108, 111]);
+
+  // Note: z.hex() doesn't accept 0x prefix, but our utility function can handle it
+  // const decodedWithPrefix = z.decode(codec, "0x48656c6c6f");
+  // expect(Array.from(decodedWithPrefix)).toEqual([72, 101, 108, 108, 111]);
+
+  // Test encode
+  const bytes = new Uint8Array([72, 101, 108, 108, 111]);
+  expect(z.encode(codec, bytes)).toBe("48656c6c6f");
+
+  // Test round trip
+  const original = "deadbeef";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe("deadbeef");
+});
+
+// ============================================================================
+// stringToURL
+// ============================================================================
+
+const stringToURL = () =>
+  z.codec(z.url(), z.instanceof(URL), {
+    decode: (urlString) => new URL(urlString),
+    encode: (url) => url.href,
+  });
+
+test("stringToURL codec", () => {
+  const codec = stringToURL();
+
+  // Test decode
+  const decoded = z.decode(codec, "https://example.com/path?query=value");
+  expect(decoded).toBeInstanceOf(URL);
+  expect(decoded.hostname).toBe("example.com");
+  expect(decoded.pathname).toBe("/path");
+  expect(decoded.search).toBe("?query=value");
+
+  // Test encode
+  const url = new URL("https://example.com/path?query=value");
+  expect(z.encode(codec, url)).toBe("https://example.com/path?query=value");
+
+  // Test round trip
+  const original = "https://test.com/api/v1?foo=bar&baz=qux";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe(original);
+});
+
+// ============================================================================
+// stringToHttpURL
+// ============================================================================
+
+const stringToHttpURL = () =>
+  z.codec(z.httpUrl(), z.instanceof(URL), {
+    decode: (urlString) => new URL(urlString),
+    encode: (url) => url.href,
+  });
+
+test("stringToHttpURL codec", () => {
+  const codec = stringToHttpURL();
+
+  // Test decode HTTPS
+  const decodedHttps = z.decode(codec, "https://example.com/path");
+  expect(decodedHttps).toBeInstanceOf(URL);
+  expect(decodedHttps.protocol).toBe("https:");
+
+  // Test decode HTTP
+  const decodedHttp = z.decode(codec, "http://example.com/path");
+  expect(decodedHttp).toBeInstanceOf(URL);
+  expect(decodedHttp.protocol).toBe("http:");
+
+  // Test encode
+  const url = new URL("https://example.com/path");
+  expect(z.encode(codec, url)).toBe("https://example.com/path");
+
+  // Test round trip
+  const original = "http://api.example.com/v1/users";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe(original);
+});
+
+// ============================================================================
+// uriComponent
+// ============================================================================
+
+const uriComponent = () =>
+  z.codec(z.string(), z.string(), {
+    decode: (encodedString) => decodeURIComponent(encodedString),
+    encode: (decodedString) => encodeURIComponent(decodedString),
+  });
+
+test("uriComponent codec", () => {
+  const codec = uriComponent();
+
+  // Test decode
+  const decoded = z.decode(codec, "Hello%20World%21");
+  expect(decoded).toBe("Hello World!");
+
+  // Test encode
+  const encoded = z.encode(codec, "Hello World!");
+  expect(encoded).toBe("Hello%20World!");
+
+  // Test round trip
+  const original = "Hello%20World%21%20%26%20More";
+  const roundTrip = z.encode(codec, z.decode(codec, original));
+  expect(roundTrip).toBe("Hello%20World!%20%26%20More");
+
+  // Test complex characters
+  const complex = "café & résumé";
+  const encodedComplex = z.encode(codec, complex);
+  const decodedComplex = z.decode(codec, encodedComplex);
+  expect(decodedComplex).toBe(complex);
+});
+
+// ============================================================================
+// stringToBoolean
+// ============================================================================
+
+const stringToBoolean = (options?: { truthy?: string[]; falsy?: string[] }) => z.stringbool(options);
+
+test("stringToBoolean codec", () => {
+  const codec = stringToBoolean();
+
+  // Test decode - default truthy values
+  expect(z.decode(codec, "true")).toBe(true);
+  expect(z.decode(codec, "yes")).toBe(true);
+  expect(z.decode(codec, "1")).toBe(true);
+
+  // Test decode - default falsy values
+  expect(z.decode(codec, "false")).toBe(false);
+  expect(z.decode(codec, "no")).toBe(false);
+  expect(z.decode(codec, "0")).toBe(false);
+
+  // Test encode - default behavior
+  expect(z.encode(codec, true)).toBe("true");
+  expect(z.encode(codec, false)).toBe("false");
+
+  // Test custom options
+  const customCodec = stringToBoolean({ truthy: ["yes", "y"], falsy: ["no", "n"] });
+  expect(z.decode(customCodec, "yes")).toBe(true);
+  expect(z.decode(customCodec, "y")).toBe(true);
+  expect(z.decode(customCodec, "no")).toBe(false);
+  expect(z.decode(customCodec, "n")).toBe(false);
+  expect(z.encode(customCodec, true)).toBe("yes");
+  expect(z.encode(customCodec, false)).toBe("no");
+});
+
+// ============================================================================
+// Error Handling Tests
+// ============================================================================
+
+// Test error cases - these test input validation, not transform errors
+test("codec input validation", () => {
+  // Test invalid base64 format
+  const base64Codec = base64();
+  const invalidBase64Result = z.safeDecode(base64Codec, "invalid!@#");
+  expect(invalidBase64Result.success).toBe(false);
+
+  // Test invalid hex format
+  const hexCodec = hexToBytes();
+  const invalidHexResult = z.safeDecode(hexCodec, "gg");
+  expect(invalidHexResult.success).toBe(false);
+
+  // Test invalid URL format
+  const urlCodec = stringToURL();
+  const invalidUrlResult = z.safeDecode(urlCodec, "not a url");
+  expect(invalidUrlResult.success).toBe(false);
+
+  // Test invalid HTTP URL format
+  const httpUrlCodec = stringToHttpURL();
+  const invalidHttpResult = z.safeDecode(httpUrlCodec, "ftp://example.com");
+  expect(invalidHttpResult.success).toBe(false);
+});
+
+// Test transform errors - these test errors added by transform functions
+test("codec transform error handling", () => {
+  // JSON codec that can fail during transform
+  const anyJSON = jsonCodec(z.json());
+
+  // Test successful JSON parsing
+  const validResult = z.safeDecode(anyJSON, '{"valid": "json"}');
+  expect(validResult.success).toBe(true);
+  if (validResult.success) {
+    expect(validResult.data).toEqual({ valid: "json" });
+  }
+
+  // Test invalid JSON that should create a single "invalid_format" issue
+  // Verifies that the transform error aborts before reaching the output schema
+  const invalidResult = z.safeDecode(anyJSON, '{"invalid":,}');
+  expect(invalidResult.success).toBe(false);
+  if (!invalidResult.success) {
+    expect(invalidResult.error.issues).toMatchInlineSnapshot(`
+      [
+        {
+          "code": "invalid_format",
+          "format": "json",
+          "message": "Unexpected token ',', "{"invalid":,}" is not valid JSON",
+          "path": [],
+        },
+      ]
+    `);
+  }
+});