@fabrika/app 0.0.1

package/src/standard-schema.ts

@@ -0,0 +1,75 @@
+// ─── Standard Schema v1 ──────────────────────────────────────────────
+//
+// The validator-agnostic contract (https://standardschema.dev) — a tiny spec authored by the
+// zod / valibot / arktype maintainers. Any conforming validator exposes a `~standard` property, so
+// @fabrika/app accepts ANY of them for `.input()` / `.output()` (not just zod). It is the modern,
+// library-neutral successor to a bespoke `{ parse(input): T }` interface (which is really zod-only —
+// valibot/arktype don't expose `.parse()`).
+//
+// Vendored as TYPES ONLY (the spec explicitly blesses copying it in rather than taking a dependency);
+// erased at build, so validation libraries remain optional. Verbatim from the spec.
+
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+	/** The Standard Schema properties. */
+	readonly '~standard': StandardSchemaV1.Props<Input, Output>
+}
+
+export declare namespace StandardSchemaV1 {
+	/** The Standard Schema properties interface. */
+	export interface Props<Input = unknown, Output = Input> {
+		/** The version number of the standard. */
+		readonly version: 1
+		/** The vendor name of the schema library. */
+		readonly vendor: string
+		/** Validates unknown input values. */
+		readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>
+		/** Inferred types associated with the schema. */
+		readonly types?: Types<Input, Output> | undefined
+	}
+
+	/** The result interface of the validate function. */
+	export type Result<Output> = SuccessResult<Output> | FailureResult
+
+	/** The result interface if validation succeeds. */
+	export interface SuccessResult<Output> {
+		/** The typed output value. */
+		readonly value: Output
+		/** The non-existent issues. */
+		readonly issues?: undefined
+	}
+
+	/** The result interface if validation fails. */
+	export interface FailureResult {
+		/** The issues of failed validation. */
+		readonly issues: ReadonlyArray<Issue>
+	}
+
+	/** The issue interface of the failure output. */
+	export interface Issue {
+		/** The error message of the issue. */
+		readonly message: string
+		/** The path of the issue, if any. */
+		readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined
+	}
+
+	/** The path segment interface of the issue. */
+	export interface PathSegment {
+		/** The key representing a path segment. */
+		readonly key: PropertyKey
+	}
+
+	/** The Standard Schema types interface. */
+	export interface Types<Input = unknown, Output = Input> {
+		/** The input type of the schema. */
+		readonly input: Input
+		/** The output type of the schema. */
+		readonly output: Output
+	}
+
+	/** Infers the input type of a Standard Schema. */
+	export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input']
+
+	/** Infers the output type of a Standard Schema. */
+	export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output']
+}

package/src/testing.ts

@@ -0,0 +1,119 @@
+import type { FabrikaApp, RequestExecutionContext } from './app.js'
+import { createBunHandler } from './bun.js'
+import { type CloudflareExecutionContext, createCloudflareWorker } from './cloudflare.js'
+
+export type AppTestRuntime = 'direct' | 'bun' | 'cloudflare'
+
+export interface NormalizedAppResponse {
+	readonly status: number
+	readonly headers: ReadonlyArray<readonly [name: string, value: string]>
+	readonly body: string
+}
+
+export interface AppRuntimeResponses {
+	readonly direct: NormalizedAppResponse
+	readonly bun: NormalizedAppResponse
+	readonly cloudflare: NormalizedAppResponse
+}
+
+export interface AppRuntimeConformanceOptions<Env> {
+	readonly app: FabrikaApp<Env>
+	/** Create isolated runtime state so one execution cannot affect the next. */
+	readonly createEnv: () => Env | Promise<Env>
+	/** Create an equivalent fresh request for each runtime. */
+	readonly createRequest: () => Request
+	/** Optional sink for rejected background work. */
+	readonly onBackgroundError?: (runtime: AppTestRuntime, error: unknown) => void
+}
+
+interface TrackedExecution {
+	readonly context: RequestExecutionContext
+	drain(): Promise<void>
+}
+
+function trackedExecution(onBackgroundError: (error: unknown) => void): TrackedExecution {
+	const pending = new Set<Promise<void>>()
+	const waitUntil = (promise: Promise<unknown>): void => {
+		const tracked = promise.then(
+			() => undefined,
+			(error) => {
+				try {
+					onBackgroundError(error)
+				} catch {
+					// Reporting failures must not prevent the conformance run from draining.
+				}
+			},
+		)
+		pending.add(tracked)
+		void tracked.then(() => pending.delete(tracked))
+	}
+	return {
+		context: { waitUntil },
+		async drain() {
+			while (pending.size > 0) {
+				await Promise.all(pending)
+			}
+		},
+	}
+}
+
+/** Convert a Fetch response into a deterministic value suitable for equality checks. */
+export async function normalizeAppResponse(response: Response): Promise<NormalizedAppResponse> {
+	const headers: Array<readonly [name: string, value: string]> = []
+	response.headers.forEach((value, name) => headers.push([name, value]))
+	headers.sort(([left], [right]) => left.localeCompare(right))
+	return {
+		status: response.status,
+		headers,
+		body: await response.text(),
+	}
+}
+
+async function runDirect<Env>(options: AppRuntimeConformanceOptions<Env>): Promise<NormalizedAppResponse> {
+	const execution = trackedExecution((error) => options.onBackgroundError?.('direct', error))
+	const env = await options.createEnv()
+	const request = options.createRequest()
+	const response = await options.app.fetch(request, env, execution.context)
+	await execution.drain()
+	return normalizeAppResponse(response)
+}
+
+async function runBun<Env>(options: AppRuntimeConformanceOptions<Env>): Promise<NormalizedAppResponse> {
+	const handler = createBunHandler(options.app, await options.createEnv(), {
+		onBackgroundError: (error) => options.onBackgroundError?.('bun', error),
+	})
+	const response = await handler.fetch(options.createRequest())
+	await handler.drain()
+	return normalizeAppResponse(response)
+}
+
+async function runCloudflare<Env>(options: AppRuntimeConformanceOptions<Env>): Promise<NormalizedAppResponse> {
+	const execution = trackedExecution((error) => options.onBackgroundError?.('cloudflare', error))
+	const context: CloudflareExecutionContext = {
+		waitUntil: execution.context.waitUntil,
+		passThroughOnException() {},
+	}
+	const env = await options.createEnv()
+	const request = options.createRequest()
+	const response = await createCloudflareWorker(options.app).fetch(request, env, context)
+	await execution.drain()
+	return normalizeAppResponse(response)
+}
+
+/** Execute one request through every supported HTTP adapter. */
+export async function runAppRuntimeConformance<Env>(options: AppRuntimeConformanceOptions<Env>): Promise<AppRuntimeResponses> {
+	const direct = await runDirect(options)
+	const bun = await runBun(options)
+	const cloudflare = await runCloudflare(options)
+	return { direct, bun, cloudflare }
+}
+
+/** Assert adapter parity without coupling application packages to a specific test runner. */
+export async function assertAppRuntimeConformance<Env>(options: AppRuntimeConformanceOptions<Env>): Promise<NormalizedAppResponse> {
+	const responses = await runAppRuntimeConformance(options)
+	const direct = JSON.stringify(responses.direct)
+	if (JSON.stringify(responses.bun) !== direct || JSON.stringify(responses.cloudflare) !== direct) {
+		throw new Error(`application runtime responses differ: ${JSON.stringify(responses)}`)
+	}
+	return responses.direct
+}