FM / tests

/opt/canhelp/node_modules/better-auth/node_modules/zod/src/v4/classic/tests/

/opt/canhelp/node_modules/better-auth/node_modules/zod/src/v4/classic/tests

Name	Size	Mode	Actions
anyunknown.test.ts	639	0644	edit dl rm
apply.test.ts	1509	0644	edit dl rm
array.test.ts	7248	0644	edit dl rm
assignability.test.ts	6790	0644	edit dl rm
async-parsing.test.ts	12311	0644	edit dl rm
async-refinements.test.ts	1867	0644	edit dl rm
base.test.ts	179	0644	edit dl rm
bigint.test.ts	1956	0644	edit dl rm
brand.test.ts	3574	0644	edit dl rm
catch.test.ts	7831	0644	edit dl rm
coalesce.test.ts	743	0644	edit dl rm
codec-examples.test.ts	19030	0644	edit dl rm
codec.test.ts	18853	0644	edit dl rm
coerce.test.ts	7736	0644	edit dl rm
continuability.test.ts	8020	0644	edit dl rm
custom.test.ts	1215	0644	edit dl rm
date.test.ts	1671	0644	edit dl rm
datetime.test.ts	11932	0644	edit dl rm
default.test.ts	9226	0644	edit dl rm
describe-meta-checks.test.ts	965	0644	edit dl rm
description.test.ts	1294	0644	edit dl rm
discriminated-unions.test.ts	17665	0644	edit dl rm
enum.test.ts	8488	0644	edit dl rm
error-utils.test.ts	13744	0644	edit dl rm
error.test.ts	19502	0644	edit dl rm
file.test.ts	2641	0644	edit dl rm
firstparty.test.ts	3045	0644	edit dl rm
fix-json-issue.test.ts	771	0644	edit dl rm
from-json-schema.test.ts	21498	0644	edit dl rm
function.test.ts	8344	0644	edit dl rm
generics.test.ts	2162	0644	edit dl rm
hash.test.ts	3204	0644	edit dl rm
index.test.ts	31191	0644	edit dl rm
instanceof.test.ts	1658	0644	edit dl rm
intersection.test.ts	5555	0644	edit dl rm
json.test.ts	3327	0644	edit dl rm
lazy.test.ts	4756	0644	edit dl rm
literal.test.ts	3095	0644	edit dl rm
map.test.ts	7622	0644	edit dl rm
nan.test.ts	645	0644	edit dl rm
nested-refine.test.ts	3623	0644	edit dl rm
nonoptional.test.ts	2841	0644	edit dl rm
nullable.test.ts	591	0644	edit dl rm
number.test.ts	8644	0644	edit dl rm
object.test.ts	18481	0644	edit dl rm
optional.test.ts	7332	0644	edit dl rm
partial.test.ts	12973	0644	edit dl rm
pickomit.test.ts	6885	0644	edit dl rm
pipe.test.ts	2338	0644	edit dl rm
prefault.test.ts	2063	0644	edit dl rm
preprocess.test.ts	6522	0644	edit dl rm
primitive.test.ts	7649	0644	edit dl rm
promise.test.ts	2324	0644	edit dl rm
prototypes.test.ts	498	0644	edit dl rm
readonly.test.ts	11786	0644	edit dl rm
record.test.ts	17226	0644	edit dl rm
recursive-types.test.ts	12693	0644	edit dl rm
refine.test.ts	15649	0644	edit dl rm
registries.test.ts	7391	0644	edit dl rm
set.test.ts	5622	0644	edit dl rm
standard-schema.test.ts	3770	0644	edit dl rm
string-formats.test.ts	3700	0644	edit dl rm
string.test.ts	78069	0644	edit dl rm
stringbool.test.ts	3536	0644	edit dl rm
template-literal.test.ts	35894	0644	edit dl rm
to-json-schema-methods.test.ts	10100	0644	edit dl rm
to-json-schema.test.ts	78639	0644	edit dl rm
transform.test.ts	8298	0644	edit dl rm
tuple.test.ts	5532	0644	edit dl rm
union.test.ts	5936	0644	edit dl rm
url.test.ts	402	0644	edit dl rm
validations.test.ts	6736	0644	edit dl rm
void.test.ts	306	0644	edit dl rm

Edit: /opt/canhelp/node_modules/better-auth/node_modules/zod/src/v4/classic/tests/optional.test.ts (7332B)

// @ts-ignore TS6133
import { expect, expectTypeOf, test } from "vitest";

import * as z from "zod/v4";

test(".optional()", () => {
  const schema = z.string().optional();
  expect(schema.parse("adsf")).toEqual("adsf");
  expect(schema.parse(undefined)).toEqual(undefined);
  expect(schema.safeParse(null).success).toEqual(false);

expectTypeOf<typeof schema._output>().toEqualTypeOf<string | undefined>();
});

test("unwrap", () => {
  const unwrapped = z.string().optional().unwrap();
  expect(unwrapped).toBeInstanceOf(z.ZodString);
});

test("optionality", () => {
  const a = z.string();
  expect(a._zod.optin).toEqual(undefined);
  expect(a._zod.optout).toEqual(undefined);

const b = z.string().optional();
  expect(b._zod.optin).toEqual("optional");
  expect(b._zod.optout).toEqual("optional");

const c = z.string().default("asdf");
  expect(c._zod.optin).toEqual("optional");
  expect(c._zod.optout).toEqual(undefined);

const d = z.string().optional().nullable();
  expect(d._zod.optin).toEqual("optional");
  expect(d._zod.optout).toEqual("optional");

const e = z.string().default("asdf").nullable();
  expect(e._zod.optin).toEqual("optional");
  expect(e._zod.optout).toEqual(undefined);

// z.undefined should NOT be optional
  const f = z.undefined();
  expect(f._zod.optin).toEqual("optional");
  expect(f._zod.optout).toEqual("optional");
  expectTypeOf<typeof f._zod.optin>().toEqualTypeOf<"optional" | undefined>();
  expectTypeOf<typeof f._zod.optout>().toEqualTypeOf<"optional" | undefined>();

// z.union should be optional if any of the types are optional
  const g = z.union([z.string(), z.undefined()]);
  expect(g._zod.optin).toEqual("optional");
  expect(g._zod.optout).toEqual("optional");
  expectTypeOf<typeof g._zod.optin>().toEqualTypeOf<"optional" | undefined>();
  expectTypeOf<typeof g._zod.optout>().toEqualTypeOf<"optional" | undefined>();

const h = z.union([z.string(), z.optional(z.string())]);
  expect(h._zod.optin).toEqual("optional");
  expect(h._zod.optout).toEqual("optional");
  expectTypeOf<typeof h._zod.optin>().toEqualTypeOf<"optional">();
  expectTypeOf<typeof h._zod.optout>().toEqualTypeOf<"optional">();
});

test("pipe optionality", () => {
  z.string().optional()._zod.optin;
  const a = z.string().optional().pipe(z.string());
  expect(a._zod.optin).toEqual("optional");
  expect(a._zod.optout).toEqual(undefined);
  expectTypeOf<typeof a._zod.optin>().toEqualTypeOf<"optional">();
  expectTypeOf<typeof a._zod.optout>().toEqualTypeOf<"optional" | undefined>();

const b = z
    .string()
    .transform((val) => (Math.random() ? val : undefined))
    .pipe(z.string().optional());
  expect(b._zod.optin).toEqual(undefined);
  expect(b._zod.optout).toEqual("optional");
  expectTypeOf<typeof b._zod.optin>().toEqualTypeOf<"optional" | undefined>();
  expectTypeOf<typeof b._zod.optout>().toEqualTypeOf<"optional">();

const c = z.string().default("asdf").pipe(z.string());
  expect(c._zod.optin).toEqual("optional");
  expect(c._zod.optout).toEqual(undefined);

const d = z
    .string()
    .transform((val) => (Math.random() ? val : undefined))
    .pipe(z.string().default("asdf"));
  expect(d._zod.optin).toEqual(undefined);
  expect(d._zod.optout).toEqual(undefined);
});

test("pipe optionality inside objects", () => {
  const schema = z.object({
    a: z.string().optional(),
    b: z.string().optional().pipe(z.string()),
    c: z.string().default("asdf").pipe(z.string()),
    d: z
      .string()
      .transform((val) => (Math.random() ? val : undefined))
      .pipe(z.string().optional()),
    e: z
      .string()
      .transform((val) => (Math.random() ? val : undefined))
      .pipe(z.string().default("asdf")),
  });

type SchemaIn = z.input<typeof schema>;
  expectTypeOf<SchemaIn>().toEqualTypeOf<{
    a?: string | undefined;
    b?: string | undefined;
    c?: string | undefined;
    d: string;
    e: string;
  }>();

type SchemaOut = z.output<typeof schema>;
  expectTypeOf<SchemaOut>().toEqualTypeOf<{
    a?: string | undefined;
    b: string;
    c: string;
    d?: string | undefined;
    e: string;
  }>();
});

test("optional prop with pipe", () => {
  const schema = z.object({
    id: z
      .union([z.number(), z.string().nullish()])
      .transform((val) => (val === null || val === undefined ? val : Number(val)))
      .pipe(z.number())
      .optional(),
  });

schema.parse({});
  schema.parse({}, { jitless: true });
});

// exactOptional tests
test(".exactOptional()", () => {
  const schema = z.string().exactOptional();
  expect(schema.parse("asdf")).toEqual("asdf");
  expect(schema.safeParse(undefined).success).toEqual(false);
  expect(schema.safeParse(null).success).toEqual(false);

// Type should NOT include undefined
  expectTypeOf<typeof schema._output>().toEqualTypeOf<string>();
  expectTypeOf<typeof schema._input>().toEqualTypeOf<string>();
});

test("exactOptional unwrap", () => {
  const unwrapped = z.string().exactOptional().unwrap();
  expect(unwrapped).toBeInstanceOf(z.ZodString);
});

test("exactOptional optionality", () => {
  const a = z.string().exactOptional();
  expect(a._zod.optin).toEqual("optional");
  expect(a._zod.optout).toEqual("optional");
  expectTypeOf<typeof a._zod.optin>().toEqualTypeOf<"optional">();
  expectTypeOf<typeof a._zod.optout>().toEqualTypeOf<"optional">();
});

test("exactOptional in objects - absent keys", () => {
  const schema = z.object({
    a: z.string().exactOptional(),
  });

// Absent key should pass
  expect(schema.parse({})).toEqual({});
  expect(schema.parse({}, { jitless: true })).toEqual({});

// Present key with valid value should pass
  expect(schema.parse({ a: "hello" })).toEqual({ a: "hello" });
  expect(schema.parse({ a: "hello" }, { jitless: true })).toEqual({ a: "hello" });
});

test("exactOptional in objects - explicit undefined rejected", () => {
  const schema = z.object({
    a: z.string().exactOptional(),
  });

// Explicit undefined should fail
  expect(schema.safeParse({ a: undefined }).success).toEqual(false);
  expect(schema.safeParse({ a: undefined }, { jitless: true }).success).toEqual(false);
});

test("exactOptional type inference in objects", () => {
  const schema = z.object({
    a: z.string().exactOptional(),
    b: z.string().optional(),
  });

type SchemaIn = z.input<typeof schema>;
  expectTypeOf<SchemaIn>().toEqualTypeOf<{
    a?: string;
    b?: string | undefined;
  }>();

type SchemaOut = z.output<typeof schema>;
  expectTypeOf<SchemaOut>().toEqualTypeOf<{
    a?: string;
    b?: string | undefined;
  }>();
});

test("exactOptional vs optional comparison", () => {
  const optionalSchema = z.object({ a: z.string().optional() });
  const exactOptionalSchema = z.object({ a: z.string().exactOptional() });

// Both accept absent keys
  expect(optionalSchema.parse({})).toEqual({});
  expect(exactOptionalSchema.parse({})).toEqual({});

// Both accept valid values
  expect(optionalSchema.parse({ a: "hi" })).toEqual({ a: "hi" });
  expect(exactOptionalSchema.parse({ a: "hi" })).toEqual({ a: "hi" });

// optional() accepts explicit undefined
  expect(optionalSchema.parse({ a: undefined })).toEqual({ a: undefined });

// exactOptional() rejects explicit undefined
  expect(exactOptionalSchema.safeParse({ a: undefined }).success).toEqual(false);
});

// @ts-ignore TS6133 import { expect, expectTypeOf, test } from "vitest"; import * as z from "zod/v4"; test(".optional()", () => { const schema = z.string().optional(); expect(schema.parse("adsf")).toEqual("adsf"); expect(schema.parse(undefined)).toEqual(undefined); expect(schema.safeParse(null).success).toEqual(false); expectTypeOf().toEqualTypeOf(); }); test("unwrap", () => { const unwrapped = z.string().optional().unwrap(); expect(unwrapped).toBeInstanceOf(z.ZodString); }); test("optionality", () => { const a = z.string(); expect(a._zod.optin).toEqual(undefined); expect(a._zod.optout).toEqual(undefined); const b = z.string().optional(); expect(b._zod.optin).toEqual("optional"); expect(b._zod.optout).toEqual("optional"); const c = z.string().default("asdf"); expect(c._zod.optin).toEqual("optional"); expect(c._zod.optout).toEqual(undefined); const d = z.string().optional().nullable(); expect(d._zod.optin).toEqual("optional"); expect(d._zod.optout).toEqual("optional"); const e = z.string().default("asdf").nullable(); expect(e._zod.optin).toEqual("optional"); expect(e._zod.optout).toEqual(undefined); // z.undefined should NOT be optional const f = z.undefined(); expect(f._zod.optin).toEqual("optional"); expect(f._zod.optout).toEqual("optional"); expectTypeOf().toEqualTypeOf<"optional" | undefined>(); expectTypeOf().toEqualTypeOf<"optional" | undefined>(); // z.union should be optional if any of the types are optional const g = z.union([z.string(), z.undefined()]); expect(g._zod.optin).toEqual("optional"); expect(g._zod.optout).toEqual("optional"); expectTypeOf().toEqualTypeOf<"optional" | undefined>(); expectTypeOf().toEqualTypeOf<"optional" | undefined>(); const h = z.union([z.string(), z.optional(z.string())]); expect(h._zod.optin).toEqual("optional"); expect(h._zod.optout).toEqual("optional"); expectTypeOf().toEqualTypeOf<"optional">(); expectTypeOf().toEqualTypeOf<"optional">(); }); test("pipe optionality", () => { z.string().optional()._zod.optin; const a = z.string().optional().pipe(z.string()); expect(a._zod.optin).toEqual("optional"); expect(a._zod.optout).toEqual(undefined); expectTypeOf().toEqualTypeOf<"optional">(); expectTypeOf().toEqualTypeOf<"optional" | undefined>(); const b = z .string() .transform((val) => (Math.random() ? val : undefined)) .pipe(z.string().optional()); expect(b._zod.optin).toEqual(undefined); expect(b._zod.optout).toEqual("optional"); expectTypeOf().toEqualTypeOf<"optional" | undefined>(); expectTypeOf().toEqualTypeOf<"optional">(); const c = z.string().default("asdf").pipe(z.string()); expect(c._zod.optin).toEqual("optional"); expect(c._zod.optout).toEqual(undefined); const d = z .string() .transform((val) => (Math.random() ? val : undefined)) .pipe(z.string().default("asdf")); expect(d._zod.optin).toEqual(undefined); expect(d._zod.optout).toEqual(undefined); }); test("pipe optionality inside objects", () => { const schema = z.object({ a: z.string().optional(), b: z.string().optional().pipe(z.string()), c: z.string().default("asdf").pipe(z.string()), d: z .string() .transform((val) => (Math.random() ? val : undefined)) .pipe(z.string().optional()), e: z .string() .transform((val) => (Math.random() ? val : undefined)) .pipe(z.string().default("asdf")), }); type SchemaIn = z.input; expectTypeOf().toEqualTypeOf<{ a?: string | undefined; b?: string | undefined; c?: string | undefined; d: string; e: string; }>(); type SchemaOut = z.output; expectTypeOf().toEqualTypeOf<{ a?: string | undefined; b: string; c: string; d?: string | undefined; e: string; }>(); }); test("optional prop with pipe", () => { const schema = z.object({ id: z .union([z.number(), z.string().nullish()]) .transform((val) => (val === null || val === undefined ? val : Number(val))) .pipe(z.number()) .optional(), }); schema.parse({}); schema.parse({}, { jitless: true }); }); // exactOptional tests test(".exactOptional()", () => { const schema = z.string().exactOptional(); expect(schema.parse("asdf")).toEqual("asdf"); expect(schema.safeParse(undefined).success).toEqual(false); expect(schema.safeParse(null).success).toEqual(false); // Type should NOT include undefined expectTypeOf().toEqualTypeOf(); expectTypeOf().toEqualTypeOf(); }); test("exactOptional unwrap", () => { const unwrapped = z.string().exactOptional().unwrap(); expect(unwrapped).toBeInstanceOf(z.ZodString); }); test("exactOptional optionality", () => { const a = z.string().exactOptional(); expect(a._zod.optin).toEqual("optional"); expect(a._zod.optout).toEqual("optional"); expectTypeOf().toEqualTypeOf<"optional">(); expectTypeOf().toEqualTypeOf<"optional">(); }); test("exactOptional in objects - absent keys", () => { const schema = z.object({ a: z.string().exactOptional(), }); // Absent key should pass expect(schema.parse({})).toEqual({}); expect(schema.parse({}, { jitless: true })).toEqual({}); // Present key with valid value should pass expect(schema.parse({ a: "hello" })).toEqual({ a: "hello" }); expect(schema.parse({ a: "hello" }, { jitless: true })).toEqual({ a: "hello" }); }); test("exactOptional in objects - explicit undefined rejected", () => { const schema = z.object({ a: z.string().exactOptional(), }); // Explicit undefined should fail expect(schema.safeParse({ a: undefined }).success).toEqual(false); expect(schema.safeParse({ a: undefined }, { jitless: true }).success).toEqual(false); }); test("exactOptional type inference in objects", () => { const schema = z.object({ a: z.string().exactOptional(), b: z.string().optional(), }); type SchemaIn = z.input; expectTypeOf().toEqualTypeOf<{ a?: string; b?: string | undefined; }>(); type SchemaOut = z.output; expectTypeOf().toEqualTypeOf<{ a?: string; b?: string | undefined; }>(); }); test("exactOptional vs optional comparison", () => { const optionalSchema = z.object({ a: z.string().optional() }); const exactOptionalSchema = z.object({ a: z.string().exactOptional() }); // Both accept absent keys expect(optionalSchema.parse({})).toEqual({}); expect(exactOptionalSchema.parse({})).toEqual({}); // Both accept valid values expect(optionalSchema.parse({ a: "hi" })).toEqual({ a: "hi" }); expect(exactOptionalSchema.parse({ a: "hi" })).toEqual({ a: "hi" }); // optional() accepts explicit undefined expect(optionalSchema.parse({ a: undefined })).toEqual({ a: undefined }); // exactOptional() rejects explicit undefined expect(exactOptionalSchema.safeParse({ a: undefined }).success).toEqual(false); });