hanzio 3.0.0 → 3.1.0

package/src/testing/module-mocker.ts

@@ -0,0 +1,50 @@
+type ModuleExports = Record<string, unknown>
+
+/**
+ * `mock.module` that can be undone. Bun replaces a mocked module for the whole
+ * process and `mock.restore()` does not bring it back
+ * (https://github.com/oven-sh/bun/issues/7823), so one suite's stub silently
+ * leaks into every later suite.
+ *
+ * Mocks spread the module's real exports first, so exports you don't override
+ * keep working, and `clear()` re-registers the originals. Call it in
+ * `afterEach` or `afterAll`.
+ *
+ * Bun resolves specifiers relative to the file that registers the mock, so
+ * pass absolute paths or package names. A `resolve` function maps your own
+ * shorthand (an `@/` alias, a source-root-relative path) to absolute paths.
+ *
+ * @example
+ * const moduleMocker = new ModuleMocker((specifier) =>
+ *   specifier.startsWith('@/') ? path.resolve(srcDir, specifier.slice(2)) : specifier
+ * )
+ * await moduleMocker.mock('@/lib/posthog', () => ({ captureException: mock() }))
+ * afterAll(() => moduleMocker.clear())
+ */
+export class ModuleMocker {
+	private restorers: (() => void)[] = []
+
+	constructor(
+		private readonly resolve: (specifier: string) => string = (specifier) =>
+			specifier
+	) {}
+
+	async mock(
+		specifier: string,
+		renderMocks: () => ModuleExports
+	): Promise<void> {
+		const { mock } = await import('bun:test')
+		const resolved = this.resolve(specifier)
+		const original = { ...(await import(resolved)) } as ModuleExports
+		const merged = { ...original, ...renderMocks() }
+		mock.module(resolved, () => merged)
+		this.restorers.push(() => {
+			mock.module(resolved, () => original)
+		})
+	}
+
+	clear(): void {
+		for (const restore of this.restorers) restore()
+		this.restorers = []
+	}
+}

package/src/testing/prisma.ts

@@ -0,0 +1,78 @@
+import type { Mock, mock } from 'bun:test'
+
+export type PrismaMethodMock = Mock<(...args: unknown[]) => Promise<unknown>>
+
+/**
+ * A Prisma client where every model delegate and every method is a Bun mock,
+ * created on first access, like `jest-mock-extended`'s `mockDeep()`.
+ * `$`-prefixed client methods (`$transaction`, `$queryRaw`) are mocks too.
+ */
+export type DeepMockedPrisma<Client> = {
+	[K in keyof Client]: Client[K] extends (...args: never[]) => unknown
+		? PrismaMethodMock
+		: { [Method in keyof Client[K]]: PrismaMethodMock }
+} & {
+	/** Resets every mock created so far. Call it in `beforeEach`. */
+	$reset: () => void
+}
+
+/**
+ * Builds a deep auto-mock of a Prisma client from Bun's `mock`. Register it
+ * with `mock.module` in place of the module that exports your client.
+ *
+ * @example
+ * import { mock } from 'bun:test'
+ * import type { prisma } from '../lib/prisma'
+ *
+ * export const prismaMock = createPrismaMock<typeof prisma>(mock)
+ * mock.module(prismaModulePath, () => ({ ...prismaExports, prisma: prismaMock }))
+ *
+ * prismaMock.user.findUnique.mockResolvedValue({ id: 'u1' })
+ * expect(prismaMock.user.findUnique).toHaveBeenCalledWith({ where: { id: 'u1' } })
+ */
+export function createPrismaMock<Client>(
+	createMock: typeof mock
+): DeepMockedPrisma<Client> {
+	const created: PrismaMethodMock[] = []
+	const reset = () => {
+		for (const method of created) method.mockReset()
+	}
+
+	const methodsOf = (methods: Map<string, PrismaMethodMock>, key: string) => {
+		let method = methods.get(key)
+		if (!method) {
+			method = createMock() as unknown as PrismaMethodMock
+			created.push(method)
+			methods.set(key, method)
+		}
+		return method
+	}
+
+	const delegates = new Map<string, object>()
+	const rootMethods = new Map<string, PrismaMethodMock>()
+
+	const delegateFor = (model: string) => {
+		let delegate = delegates.get(model)
+		if (!delegate) {
+			const methods = new Map<string, PrismaMethodMock>()
+			delegate = new Proxy(
+				{},
+				{
+					get: (_target, method) =>
+						typeof method === 'symbol' ? undefined : methodsOf(methods, method)
+				}
+			)
+			delegates.set(model, delegate)
+		}
+		return delegate
+	}
+
+	return new Proxy({} as DeepMockedPrisma<Client>, {
+		get(_target, property) {
+			if (property === '$reset') return reset
+			if (typeof property === 'symbol') return undefined
+			if (property.startsWith('$')) return methodsOf(rootMethods, property)
+			return delegateFor(property)
+		}
+	})
+}

package/src/testing/window.ts

@@ -0,0 +1,119 @@
+/** A complete in-memory `Storage` (`localStorage` / `sessionStorage`). */
+export function createTestStorage(): Storage {
+	const store = new Map<string, string>()
+	return {
+		get length() {
+			return store.size
+		},
+		clear: () => store.clear(),
+		getItem: (key) => store.get(key) ?? null,
+		key: (index) => [...store.keys()][index] ?? null,
+		removeItem: (key) => {
+			store.delete(key)
+		},
+		setItem: (key, value) => {
+			store.set(key, String(value))
+		}
+	}
+}
+
+type ShimLocation = Pick<
+	URL,
+	| 'href'
+	| 'origin'
+	| 'protocol'
+	| 'host'
+	| 'hostname'
+	| 'port'
+	| 'pathname'
+	| 'search'
+	| 'hash'
+>
+
+type ShimWindow = {
+	location: ShimLocation
+	addEventListener: (...args: unknown[]) => void
+	removeEventListener: (...args: unknown[]) => void
+	localStorage: Storage
+}
+
+const noop = () => {}
+
+function locationOf(href: string): ShimLocation {
+	const { origin, protocol, host, hostname, port, pathname, search, hash } =
+		new URL(href)
+	return {
+		href,
+		origin,
+		protocol,
+		host,
+		hostname,
+		port,
+		pathname,
+		search,
+		hash
+	}
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null
+}
+
+/**
+ * Installs a minimal `globalThis.window` for unit tests of browser-facing code
+ * that only probes `window` (`location`, `localStorage`, event listeners), and
+ * returns a `reset` to call in `afterEach`.
+ *
+ * Tests may assign a partial `window`. The shim keeps its own shape and copies
+ * `location`, `localStorage` and the listener functions from the assigned
+ * object, because libraries such as axios and PostHog read those at import
+ * time. It installs no `document`: Vue and PrismJS treat one as a full DOM.
+ *
+ * @example
+ * // test-setup.ts, preloaded through bunfig.toml
+ * const resetWindow = installWindowShim()
+ * afterEach(resetWindow)
+ */
+export function installWindowShim(href = 'http://localhost/'): () => void {
+	const shim: ShimWindow = {
+		location: locationOf(href),
+		addEventListener: noop,
+		removeEventListener: noop,
+		localStorage: createTestStorage()
+	}
+
+	const assign = (value: unknown) => {
+		if (!isObject(value)) return
+		if (value.localStorage) shim.localStorage = value.localStorage as Storage
+		shim.location =
+			isObject(value.location) && typeof value.location.href === 'string'
+				? (value.location as ShimLocation)
+				: locationOf(href)
+		shim.addEventListener =
+			typeof value.addEventListener === 'function'
+				? (value.addEventListener as ShimWindow['addEventListener'])
+				: noop
+		shim.removeEventListener =
+			typeof value.removeEventListener === 'function'
+				? (value.removeEventListener as ShimWindow['removeEventListener'])
+				: noop
+	}
+
+	const install = () => {
+		Object.defineProperty(globalThis, 'window', {
+			configurable: true,
+			enumerable: true,
+			get: () => shim,
+			set: assign
+		})
+	}
+
+	install()
+	return () => {
+		shim.location = locationOf(href)
+		shim.addEventListener = noop
+		shim.removeEventListener = noop
+		shim.localStorage = createTestStorage()
+		install()
+	}
+}

package/src/zod/index.ts

@@ -97,6 +97,26 @@ export const zJsonObject: z.ZodType<JsonObject> = z.record(
 	zJsonValue
 )
 
+/** An E.164 phone number: `+`, then 7 to 15 digits with no leading zero. */
+export const E164_REGEX = /^\+[1-9]\d{6,14}$/
+
+/**
+ * An optional E.164 phone number for forms: a cleared input submits `''`,
+ * which means "no number", so `''` and `null` both parse to `null`.
+ *
+ * Deliberately not `union([regex, literal('')])`: that serializes the empty
+ * literal as `enum: [""]`, which Gemini function declarations reject.
+ */
+export const zOptionalE164 = z
+	.string()
+	.refine(
+		(value) => value === '' || E164_REGEX.test(value),
+		'Phone number must be in E.164 format (e.g. +14155551234)'
+	)
+	.describe('E.164 phone number (e.g. +14155551234); empty string clears it')
+	.nullable()
+	.transform((value) => value || null)
+
 /** `JSON.parse` + `schema.safeParse` without throwing. */
 export function parseJson<S extends z.ZodType>(
 	text: string,

package/src/zod/introspect.ts

@@ -6,7 +6,7 @@ function pipeInput(def: z.core.$ZodPipeDef): Schema {
 	return defOf(def.in).type === 'transform' ? def.out : def.in
 }
 
-function unwrapOnce(def: Def): Schema | undefined {
+export function unwrapOnce(def: Def): Schema | undefined {
 	switch (def.type) {
 		case 'optional':
 		case 'nullable':