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/primitive.test.ts (7649B)

import { expect, expectTypeOf, test } from "vitest";
import * as z from "zod/v4";

const literalStringSchema = z.literal("asdf");
const literalNumberSchema = z.literal(12);
const literalBooleanSchema = z.literal(true);
const literalBigIntSchema = z.literal(BigInt(42));

const stringSchema = z.string();
const numberSchema = z.number();
const bigintSchema = z.bigint();
const booleanSchema = z.boolean();
const dateSchema = z.date();
const symbolSchema = z.symbol();
const nullSchema = z.null();
const undefinedSchema = z.undefined();
const stringSchemaOptional = z.string().optional();
const stringSchemaNullable = z.string().nullable();
const numberSchemaOptional = z.number().optional();
const numberSchemaNullable = z.number().nullable();
const bigintSchemaOptional = z.bigint().optional();
const bigintSchemaNullable = z.bigint().nullable();
const booleanSchemaOptional = z.boolean().optional();
const booleanSchemaNullable = z.boolean().nullable();
const dateSchemaOptional = z.date().optional();
const dateSchemaNullable = z.date().nullable();
const symbolSchemaOptional = z.symbol().optional();
const symbolSchemaNullable = z.symbol().nullable();

test("literal string schema", () => {
  expect(literalStringSchema.parse("asdf")).toBe("asdf");
  expect(() => literalStringSchema.parse("not_asdf")).toThrow();
  expect(() => literalStringSchema.parse(123)).toThrow();
  expect(() => literalStringSchema.parse(true)).toThrow();
  expect(() => literalStringSchema.parse({})).toThrow();
});

test("literal number schema", () => {
  expect(literalNumberSchema.parse(12)).toBe(12);
  expect(() => literalNumberSchema.parse(13)).toThrow();
  expect(() => literalNumberSchema.parse("foo")).toThrow();
  expect(() => literalNumberSchema.parse(true)).toThrow();
  expect(() => literalNumberSchema.parse({})).toThrow();
});

test("literal boolean schema", () => {
  expect(literalBooleanSchema.parse(true)).toBe(true);
  expect(() => literalBooleanSchema.parse(false)).toThrow();
  expect(() => literalBooleanSchema.parse("asdf")).toThrow();
  expect(() => literalBooleanSchema.parse(123)).toThrow();
  expect(() => literalBooleanSchema.parse({})).toThrow();
});

test("literal bigint schema", () => {
  expect(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42));
  expect(() => literalBigIntSchema.parse(BigInt(43))).toThrow();
  expect(() => literalBigIntSchema.parse("asdf")).toThrow();
  expect(() => literalBigIntSchema.parse(123)).toThrow();
  expect(() => literalBigIntSchema.parse({})).toThrow();
});

test("string schema", () => {
  stringSchema.parse("foo");
  expect(() => stringSchema.parse(Math.random())).toThrow();
  expect(() => stringSchema.parse(true)).toThrow();
  expect(() => stringSchema.parse(undefined)).toThrow();
  expect(() => stringSchema.parse(null)).toThrow();
});

test("number schema", () => {
  numberSchema.parse(Math.random());
  expect(() => numberSchema.parse("foo")).toThrow();
  expect(() => numberSchema.parse(BigInt(17))).toThrow();
  expect(() => numberSchema.parse(true)).toThrow();
  expect(() => numberSchema.parse(undefined)).toThrow();
  expect(() => numberSchema.parse(null)).toThrow();
});

test("bigint schema", () => {
  bigintSchema.parse(BigInt(17));
  expect(() => bigintSchema.parse("foo")).toThrow();
  expect(() => bigintSchema.parse(Math.random())).toThrow();
  expect(() => bigintSchema.parse(true)).toThrow();
  expect(() => bigintSchema.parse(undefined)).toThrow();
  expect(() => bigintSchema.parse(null)).toThrow();
});

test("boolean schema", () => {
  booleanSchema.parse(true);
  expect(() => booleanSchema.parse("foo")).toThrow();
  expect(() => booleanSchema.parse(Math.random())).toThrow();
  expect(() => booleanSchema.parse(undefined)).toThrow();
  expect(() => booleanSchema.parse(null)).toThrow();
});

test("date schema", async () => {
  dateSchema.parse(new Date());
  expect(() => dateSchema.parse("foo")).toThrow();
  expect(() => dateSchema.parse(Math.random())).toThrow();
  expect(() => dateSchema.parse(true)).toThrow();
  expect(() => dateSchema.parse(undefined)).toThrow();
  expect(() => dateSchema.parse(null)).toThrow();
  expect(await dateSchema.safeParseAsync(new Date("invalid"))).toMatchInlineSnapshot(`
    {
      "error": [ZodError: [
      {
        "expected": "date",
        "code": "invalid_type",
        "received": "Invalid Date",
        "path": [],
        "message": "Invalid input: expected date, received Date"
      }
    ]],
      "success": false,
    }
  `);
});

test("symbol schema", () => {
  symbolSchema.parse(Symbol("foo"));
  expect(() => symbolSchema.parse("foo")).toThrow();
  expect(() => symbolSchema.parse(Math.random())).toThrow();
  expect(() => symbolSchema.parse(true)).toThrow();
  expect(() => symbolSchema.parse(new Date())).toThrow();
  expect(() => symbolSchema.parse(undefined)).toThrow();
  expect(() => symbolSchema.parse(null)).toThrow();
});

test("undefined schema", () => {
  undefinedSchema.parse(undefined);
  expect(() => undefinedSchema.parse("foo")).toThrow();
  expect(() => undefinedSchema.parse(Math.random())).toThrow();
  expect(() => undefinedSchema.parse(true)).toThrow();
  expect(() => undefinedSchema.parse(null)).toThrow();
});

test("null schema", () => {
  nullSchema.parse(null);
  expect(() => nullSchema.parse("foo")).toThrow();
  expect(() => nullSchema.parse(Math.random())).toThrow();
  expect(() => nullSchema.parse(true)).toThrow();
  expect(() => nullSchema.parse(undefined)).toThrow();
});

test("primitive inference", () => {
  expectTypeOf<z.TypeOf<typeof literalStringSchema>>().toEqualTypeOf<"asdf">();
  expectTypeOf<z.TypeOf<typeof literalNumberSchema>>().toEqualTypeOf<12>();
  expectTypeOf<z.TypeOf<typeof literalBooleanSchema>>().toEqualTypeOf<true>();
  expectTypeOf<z.TypeOf<typeof literalBigIntSchema>>().toEqualTypeOf<bigint>();
  expectTypeOf<z.TypeOf<typeof stringSchema>>().toEqualTypeOf<string>();
  expectTypeOf<z.TypeOf<typeof numberSchema>>().toEqualTypeOf<number>();
  expectTypeOf<z.TypeOf<typeof bigintSchema>>().toEqualTypeOf<bigint>();
  expectTypeOf<z.TypeOf<typeof booleanSchema>>().toEqualTypeOf<boolean>();
  expectTypeOf<z.TypeOf<typeof dateSchema>>().toEqualTypeOf<Date>();
  expectTypeOf<z.TypeOf<typeof symbolSchema>>().toEqualTypeOf<symbol>();
  expectTypeOf<z.TypeOf<typeof nullSchema>>().toEqualTypeOf<null>();
  expectTypeOf<z.TypeOf<typeof undefinedSchema>>().toEqualTypeOf<undefined>();
  expectTypeOf<z.TypeOf<typeof stringSchemaOptional>>().toEqualTypeOf<string | undefined>();
  expectTypeOf<z.TypeOf<typeof stringSchemaNullable>>().toEqualTypeOf<string | null>();
  expectTypeOf<z.TypeOf<typeof numberSchemaOptional>>().toEqualTypeOf<number | undefined>();
  expectTypeOf<z.TypeOf<typeof numberSchemaNullable>>().toEqualTypeOf<number | null>();
  expectTypeOf<z.TypeOf<typeof bigintSchemaOptional>>().toEqualTypeOf<bigint | undefined>();
  expectTypeOf<z.TypeOf<typeof bigintSchemaNullable>>().toEqualTypeOf<bigint | null>();
  expectTypeOf<z.TypeOf<typeof booleanSchemaOptional>>().toEqualTypeOf<boolean | undefined>();
  expectTypeOf<z.TypeOf<typeof booleanSchemaNullable>>().toEqualTypeOf<boolean | null>();
  expectTypeOf<z.TypeOf<typeof dateSchemaOptional>>().toEqualTypeOf<Date | undefined>();
  expectTypeOf<z.TypeOf<typeof dateSchemaNullable>>().toEqualTypeOf<Date | null>();
  expectTypeOf<z.TypeOf<typeof symbolSchemaOptional>>().toEqualTypeOf<symbol | undefined>();
  expectTypeOf<z.TypeOf<typeof symbolSchemaNullable>>().toEqualTypeOf<symbol | null>();
});

test("get literal values", () => {
  expect(literalStringSchema.values).toEqual(new Set(["asdf"]));
  expect(literalStringSchema._zod.def.values).toEqual(["asdf"]);
});

import { expect, expectTypeOf, test } from "vitest"; import * as z from "zod/v4"; const literalStringSchema = z.literal("asdf"); const literalNumberSchema = z.literal(12); const literalBooleanSchema = z.literal(true); const literalBigIntSchema = z.literal(BigInt(42)); const stringSchema = z.string(); const numberSchema = z.number(); const bigintSchema = z.bigint(); const booleanSchema = z.boolean(); const dateSchema = z.date(); const symbolSchema = z.symbol(); const nullSchema = z.null(); const undefinedSchema = z.undefined(); const stringSchemaOptional = z.string().optional(); const stringSchemaNullable = z.string().nullable(); const numberSchemaOptional = z.number().optional(); const numberSchemaNullable = z.number().nullable(); const bigintSchemaOptional = z.bigint().optional(); const bigintSchemaNullable = z.bigint().nullable(); const booleanSchemaOptional = z.boolean().optional(); const booleanSchemaNullable = z.boolean().nullable(); const dateSchemaOptional = z.date().optional(); const dateSchemaNullable = z.date().nullable(); const symbolSchemaOptional = z.symbol().optional(); const symbolSchemaNullable = z.symbol().nullable(); test("literal string schema", () => { expect(literalStringSchema.parse("asdf")).toBe("asdf"); expect(() => literalStringSchema.parse("not_asdf")).toThrow(); expect(() => literalStringSchema.parse(123)).toThrow(); expect(() => literalStringSchema.parse(true)).toThrow(); expect(() => literalStringSchema.parse({})).toThrow(); }); test("literal number schema", () => { expect(literalNumberSchema.parse(12)).toBe(12); expect(() => literalNumberSchema.parse(13)).toThrow(); expect(() => literalNumberSchema.parse("foo")).toThrow(); expect(() => literalNumberSchema.parse(true)).toThrow(); expect(() => literalNumberSchema.parse({})).toThrow(); }); test("literal boolean schema", () => { expect(literalBooleanSchema.parse(true)).toBe(true); expect(() => literalBooleanSchema.parse(false)).toThrow(); expect(() => literalBooleanSchema.parse("asdf")).toThrow(); expect(() => literalBooleanSchema.parse(123)).toThrow(); expect(() => literalBooleanSchema.parse({})).toThrow(); }); test("literal bigint schema", () => { expect(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42)); expect(() => literalBigIntSchema.parse(BigInt(43))).toThrow(); expect(() => literalBigIntSchema.parse("asdf")).toThrow(); expect(() => literalBigIntSchema.parse(123)).toThrow(); expect(() => literalBigIntSchema.parse({})).toThrow(); }); test("string schema", () => { stringSchema.parse("foo"); expect(() => stringSchema.parse(Math.random())).toThrow(); expect(() => stringSchema.parse(true)).toThrow(); expect(() => stringSchema.parse(undefined)).toThrow(); expect(() => stringSchema.parse(null)).toThrow(); }); test("number schema", () => { numberSchema.parse(Math.random()); expect(() => numberSchema.parse("foo")).toThrow(); expect(() => numberSchema.parse(BigInt(17))).toThrow(); expect(() => numberSchema.parse(true)).toThrow(); expect(() => numberSchema.parse(undefined)).toThrow(); expect(() => numberSchema.parse(null)).toThrow(); }); test("bigint schema", () => { bigintSchema.parse(BigInt(17)); expect(() => bigintSchema.parse("foo")).toThrow(); expect(() => bigintSchema.parse(Math.random())).toThrow(); expect(() => bigintSchema.parse(true)).toThrow(); expect(() => bigintSchema.parse(undefined)).toThrow(); expect(() => bigintSchema.parse(null)).toThrow(); }); test("boolean schema", () => { booleanSchema.parse(true); expect(() => booleanSchema.parse("foo")).toThrow(); expect(() => booleanSchema.parse(Math.random())).toThrow(); expect(() => booleanSchema.parse(undefined)).toThrow(); expect(() => booleanSchema.parse(null)).toThrow(); }); test("date schema", async () => { dateSchema.parse(new Date()); expect(() => dateSchema.parse("foo")).toThrow(); expect(() => dateSchema.parse(Math.random())).toThrow(); expect(() => dateSchema.parse(true)).toThrow(); expect(() => dateSchema.parse(undefined)).toThrow(); expect(() => dateSchema.parse(null)).toThrow(); expect(await dateSchema.safeParseAsync(new Date("invalid"))).toMatchInlineSnapshot(` { "error": [ZodError: [ { "expected": "date", "code": "invalid_type", "received": "Invalid Date", "path": [], "message": "Invalid input: expected date, received Date" } ]], "success": false, } `); }); test("symbol schema", () => { symbolSchema.parse(Symbol("foo")); expect(() => symbolSchema.parse("foo")).toThrow(); expect(() => symbolSchema.parse(Math.random())).toThrow(); expect(() => symbolSchema.parse(true)).toThrow(); expect(() => symbolSchema.parse(new Date())).toThrow(); expect(() => symbolSchema.parse(undefined)).toThrow(); expect(() => symbolSchema.parse(null)).toThrow(); }); test("undefined schema", () => { undefinedSchema.parse(undefined); expect(() => undefinedSchema.parse("foo")).toThrow(); expect(() => undefinedSchema.parse(Math.random())).toThrow(); expect(() => undefinedSchema.parse(true)).toThrow(); expect(() => undefinedSchema.parse(null)).toThrow(); }); test("null schema", () => { nullSchema.parse(null); expect(() => nullSchema.parse("foo")).toThrow(); expect(() => nullSchema.parse(Math.random())).toThrow(); expect(() => nullSchema.parse(true)).toThrow(); expect(() => nullSchema.parse(undefined)).toThrow(); }); test("primitive inference", () => { expectTypeOf>().toEqualTypeOf<"asdf">(); expectTypeOf>().toEqualTypeOf<12>(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); expectTypeOf>().toEqualTypeOf(); }); test("get literal values", () => { expect(literalStringSchema.values).toEqual(new Set(["asdf"])); expect(literalStringSchema._zod.def.values).toEqual(["asdf"]); });