@hulla/api-fastify 0.0.0-stage → 2.0.1

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { AdapterErrorInput, AdapterResponse } from "@hulla/api/adapters";
+import { Awaitable, ServerAdapter, ServerContextInput, ServerExecutableFor } from "@hulla/api/server";
+import { Contract } from "@hulla/api";
+import { FastifyInstance as FastifyInstance$1, FastifyReply as FastifyReply$1, FastifyRequest as FastifyRequest$1, RouteHandlerMethod } from "fastify";
+//#region src/index.d.ts
+type FastifyInstance = FastifyInstance$1;
+type FastifyRequest = FastifyRequest$1;
+type FastifyReply = FastifyReply$1;
+type FastifyHandler = RouteHandlerMethod;
+type FastifyAdapterContext = {
+  readonly request: FastifyRequest;
+  readonly reply: FastifyReply;
+};
+type FastifyContextInput<ContractType extends Contract = Contract> = ServerContextInput<ContractType> & FastifyAdapterContext;
+type FastifyServerErrorInput = Omit<AdapterErrorInput, 'hostContext' | 'request'> & FastifyAdapterContext;
+type FastifyServerOptions = {
+  readonly onError?: ((input: FastifyServerErrorInput) => Awaitable<AdapterResponse | undefined | void>) | undefined;
+};
+type FastifyAdapter<App extends FastifyInstance = FastifyInstance> = ServerAdapter<'fastify', FastifyAdapterContext> & {
+  readonly mount: <const ContractType extends Contract, const Context extends object>(implementation: ServerExecutableFor<ContractType, Context, 'fastify', FastifyAdapterContext>, options?: FastifyServerOptions) => App;
+};
+/** Creates a Fastify adapter bound to one caller-owned application. */
+declare function fastifyAdapter<const App extends FastifyInstance>(app: App, defaults?: FastifyServerOptions): FastifyAdapter<App>;
+//#endregion
+export { FastifyAdapter, FastifyContextInput, FastifyHandler, FastifyInstance, FastifyReply, FastifyRequest, FastifyServerErrorInput, FastifyServerOptions, fastifyAdapter };

package/dist/index.js

@@ -0,0 +1,134 @@
+import { nodeRequestHeader, nodeRequestHeaders, nodeRequestLifetime } from "@hulla/api-node";
+import { createAdapterRuntime, toFetchHeaders } from "@hulla/api/adapters";
+import { assertAdapterContext, createServerAdapter, serverContextAdapterId } from "@hulla/api/server";
+
+//#region src/index.ts
+function readHeaders() {
+	return this.cachedHeaders ??= nodeRequestHeaders(this.request.headers);
+}
+function readHeader(name) {
+	return this.cachedHeaders === void 0 ? nodeRequestHeader(this.request.headers, name) : this.cachedHeaders[name];
+}
+function missingBodyParser(representation) {
+	return Promise.reject(/* @__PURE__ */ new TypeError(`Fastify request body is unavailable; install a matching content-type parser for ${representation} bodies`));
+}
+function responseSetCookies(headers) {
+	return headers.getSetCookie?.() ?? [];
+}
+function writeResponseHeaders(source, target) {
+	const setCookies = responseSetCookies(source);
+	source.forEach((value, name) => {
+		if (name !== "set-cookie" || setCookies.length === 0) target.header(name, value);
+	});
+	for (const cookie of setCookies) target.header("set-cookie", cookie);
+}
+function writeAdapterHeaders(source, target) {
+	for (const [name, value] of Object.entries(source)) target.header(name, value);
+}
+function readableStream(source) {
+	const stream = source;
+	const iterator = typeof stream?.[Symbol.asyncIterator] === "function" ? stream[Symbol.asyncIterator]() : typeof stream?.[Symbol.iterator] === "function" ? stream[Symbol.iterator]() : void 0;
+	if (iterator === void 0) throw new TypeError("Stream response body must be iterable");
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const result = await iterator.next();
+				if (result.done) controller.close();
+				else if (result.value instanceof Uint8Array) controller.enqueue(result.value);
+				else throw new TypeError("Stream chunk must be Uint8Array");
+			} catch (error) {
+				try {
+					await iterator.return?.();
+				} catch {}
+				controller.error(error);
+			}
+		},
+		async cancel(reason) {
+			await iterator.return?.(reason);
+		}
+	});
+}
+function writeFetchResponse(source, target) {
+	target.code(source.status);
+	writeResponseHeaders(source.headers, target);
+	return target.send(source.body ?? void 0);
+}
+function writeAdapterResponse(source, target) {
+	const body = source.body;
+	if (body.kind === "raw") {
+		if (!(body.value instanceof Response) || body.value.status !== source.status) throw new TypeError("Raw Fetch response status must match its declared contract status");
+		return writeFetchResponse(body.value, target);
+	}
+	if (body.kind === "form-data") {
+		if (!(body.value instanceof FormData)) throw new TypeError("Form data response body must be FormData");
+		const response = new Response(body.value, {
+			status: source.status,
+			headers: toFetchHeaders(source.headers)
+		});
+		response.headers.get("content-type");
+		return writeFetchResponse(response, target);
+	}
+	target.code(source.status);
+	writeAdapterHeaders(source.headers, target);
+	switch (body.kind) {
+		case "empty": return target.send();
+		case "json":
+			if (body.value === void 0) throw new TypeError("JSON response body cannot encode to undefined");
+			return target.send(body.value);
+		case "text":
+			if (typeof body.value !== "string") throw new TypeError("Text response body must be a string");
+			return target.send(body.value);
+		case "bytes":
+			if (!(body.value instanceof Uint8Array)) throw new TypeError("Byte response body must be Uint8Array");
+			return target.send(Buffer.from(body.value.buffer, body.value.byteOffset, body.value.byteLength));
+		case "stream": return target.send(readableStream(body.value));
+	}
+}
+function createRouteHandler(route, includeNativeContext, includeHostContext) {
+	return async (request, reply) => {
+		const lifetime = nodeRequestLifetime(request.raw, reply.raw);
+		const body = request.body === void 0 ? void 0 : { value: request.body };
+		const nativeContext = {
+			request,
+			reply
+		};
+		const input = {
+			request,
+			signal: lifetime.signal,
+			...includeNativeContext ? { contextInput: nativeContext } : {},
+			...includeHostContext ? { hostContext: nativeContext } : {},
+			params: request.params,
+			query: request.query,
+			readHeaders,
+			readHeader,
+			readBody: (representation) => missingBodyParser(representation),
+			...body === void 0 ? {} : { body }
+		};
+		return writeAdapterResponse(await route.execute(input), reply);
+	};
+}
+function mountFastify(app, implementation, options) {
+	assertAdapterContext(implementation.context, "fastify");
+	const includeNativeContext = serverContextAdapterId(implementation.context) !== void 0;
+	const runtime = createAdapterRuntime(implementation, options.onError === void 0 ? {} : { onError: ({ hostContext, ...input }) => options.onError?.({
+		...input,
+		...hostContext
+	}) });
+	for (const route of runtime.routes) app.route({
+		method: route.method,
+		url: route.path,
+		handler: createRouteHandler(route, includeNativeContext, options.onError !== void 0)
+	});
+	return app;
+}
+/** Creates a Fastify adapter bound to one caller-owned application. */
+function fastifyAdapter(app, defaults = {}) {
+	const configuredDefaults = { ...defaults };
+	return createServerAdapter("fastify", { mount: (implementation, options) => mountFastify(app, implementation, options === void 0 ? configuredDefaults : {
+		...configuredDefaults,
+		...options
+	}) });
+}
+
+//#endregion
+export { fastifyAdapter };

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@hulla/api-fastify",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.1",
+  "description": "Fastify server adapter for @hulla/api implementations",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hulladev/api.git",
+    "directory": "packages/fastify"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist coverage",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@hulla/api-node": "^2.0.1"
+  },
+  "devDependencies": {
+    "@hulla/api": "2.0.1",
+    "fastify": "^5.12.1",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@hulla/api": "^2.0.1",
+    "fastify": "^5.12.1"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.