@hulla/api-nuxt 0.0.0-stage → 2.0.0

package/dist/client.d.ts

@@ -0,0 +1,15 @@
+import { ClientTransport } from "@hulla/api/client";
+import { $Fetch } from "ofetch";
+//#region src/client.d.ts
+type NuxtRequestFetch = Pick<$Fetch, 'raw'> | {
+  /** Nitro's request-scoped event.fetch preserves local dispatch and native response metadata. */
+  readonly fetch: (url: string, options: RequestInit) => Promise<Response>;
+};
+type NuxtFetchTransportOptions = {
+  /** URL prefix placed before the contract base path. Relative paths retain Nitro's local SSR dispatch. */
+  readonly baseUrl?: string | URL;
+};
+/** Preserves response metadata over browser $fetch.raw or Nitro's request-scoped event.fetch. */
+declare function nuxtFetchTransport(fetcher: NuxtRequestFetch, options?: NuxtFetchTransportOptions): ClientTransport;
+//#endregion
+export { NuxtFetchTransportOptions, NuxtRequestFetch, nuxtFetchTransport };

package/dist/client.js

@@ -0,0 +1,72 @@
+import { fetchTransportResponse } from "@hulla/api/fetch";
+
+//#region src/client.ts
+function normalizedBaseUrl(baseUrl) {
+	return baseUrl === void 0 ? "" : String(baseUrl).replace(/\/+$/, "");
+}
+function assertBaseUrl(baseUrl) {
+	if (baseUrl === void 0) return;
+	const value = String(baseUrl);
+	if (value.includes("?")) throw new TypeError(`Nuxt fetch base URL "${value}" cannot contain a query string`);
+	if (value.includes("#")) throw new TypeError(`Nuxt fetch base URL "${value}" cannot contain a hash fragment`);
+}
+function appendBaseUrl(prefix, path) {
+	if (prefix === "") return path;
+	return path === "/" ? prefix || "/" : `${prefix}${path}`;
+}
+function requestUrl(request, baseUrl) {
+	const url = appendBaseUrl(baseUrl, request.path);
+	if (request.query === void 0) return url;
+	const parameters = new URLSearchParams();
+	for (const [key, field] of Object.entries(request.query)) {
+		if (field === void 0) continue;
+		if (typeof field === "string") parameters.append(key, field);
+		else for (const value of field) parameters.append(key, value);
+	}
+	const encoded = parameters.toString();
+	return encoded === "" ? url : `${url}?${encoded}`;
+}
+function requestBody(request) {
+	const body = request.body;
+	if (body === void 0) return void 0;
+	switch (body.kind) {
+		case "json": {
+			const encoded = JSON.stringify(body.value);
+			if (encoded === void 0) throw new TypeError("JSON request body cannot encode to undefined");
+			return encoded;
+		}
+		case "text": return body.value;
+		case "bytes": return body.value;
+		case "form-data":
+			if (!(body.value instanceof FormData)) throw new TypeError("Form data request body must be FormData");
+			return body.value;
+	}
+}
+/** Preserves response metadata over browser $fetch.raw or Nitro's request-scoped event.fetch. */
+function nuxtFetchTransport(fetcher, options = {}) {
+	assertBaseUrl(options.baseUrl);
+	const baseUrl = normalizedBaseUrl(options.baseUrl);
+	const nativeFetch = "fetch" in fetcher ? fetcher.fetch : void 0;
+	const rawFetch = "raw" in fetcher ? fetcher.raw : void 0;
+	if (typeof nativeFetch !== "function" && typeof rawFetch !== "function") throw new TypeError("Nuxt transport requires $fetch.raw or { fetch: event.fetch }; useRequestFetch() can return a parsed-only fetcher on the server");
+	const send = typeof nativeFetch === "function" ? (url, init) => nativeFetch(url, init) : (url, init) => rawFetch(url, {
+		...init,
+		ignoreResponseError: true,
+		responseType: "stream",
+		retry: false
+	});
+	return async (request) => {
+		request.signal?.throwIfAborted();
+		const body = requestBody(request);
+		const response = await send(requestUrl(request, baseUrl), {
+			...body === void 0 ? {} : { body },
+			headers: request.headers,
+			method: request.method,
+			...request.signal === void 0 ? {} : { signal: request.signal }
+		});
+		return fetchTransportResponse(response);
+	};
+}
+
+//#endregion
+export { nuxtFetchTransport };

package/dist/server.d.ts

@@ -0,0 +1,25 @@
+import { FetchServerErrorInput } from "@hulla/api/fetch";
+import { Awaitable, ServerAdapter, ServerContextInput, ServerExecutableFor } from "@hulla/api/server";
+import { H3Event } from "h3";
+import { Contract } from "@hulla/api";
+//#region src/server.d.ts
+type NuxtRequestEvent = H3Event;
+type NuxtRouteHandler = (event: NuxtRequestEvent) => Promise<Response>;
+type NuxtAdapterContext = {
+  readonly request: Request;
+  readonly nuxtEvent: NuxtRequestEvent;
+};
+type NuxtServerErrorInput = Omit<FetchServerErrorInput<NuxtRequestEvent>, 'handlerContext'> & {
+  readonly nuxtEvent: NuxtRequestEvent;
+};
+type NuxtServerOptions = {
+  readonly onError?: ((input: NuxtServerErrorInput) => Awaitable<Response | undefined | void>) | undefined;
+};
+type NuxtContextInput<ContractType extends Contract = Contract> = ServerContextInput<ContractType> & NuxtAdapterContext;
+type NuxtAdapter = ServerAdapter<'nuxt', NuxtAdapterContext> & {
+  readonly mount: <const ContractType extends Contract, const Context extends object>(implementation: ServerExecutableFor<ContractType, Context, 'nuxt', NuxtAdapterContext>, options?: NuxtServerOptions) => NuxtRouteHandler;
+};
+/** Creates a Nuxt adapter with native Nitro request-event context and mounting operations. */
+declare function nuxtAdapter(options?: NuxtServerOptions): NuxtAdapter;
+//#endregion
+export { NuxtAdapter, NuxtAdapterContext, NuxtContextInput, NuxtRequestEvent, NuxtRouteHandler, NuxtServerErrorInput, NuxtServerOptions, nuxtAdapter };

package/dist/server.js

@@ -0,0 +1,41 @@
+import { createFetchHandler } from "@hulla/api/fetch";
+import { createAdapterRuntime } from "@hulla/api/adapters";
+import { createServerAdapter } from "@hulla/api/server";
+import { toWebRequest } from "h3";
+
+//#region src/server.ts
+/** Creates a Nitro event handler backed by an @hulla/api server implementation. */
+function createRouteHandler(implementation, options = {}) {
+	const unsupported = createAdapterRuntime(implementation).routes.filter((route) => route.method === "QUERY");
+	if (unsupported.length > 0) throw new TypeError(`Nuxt server routes do not support QUERY routes: ${unsupported.map((route) => route.key.join(".")).join(", ")}`);
+	const handler = createFetchHandler(implementation, {
+		contextAdapter: "nuxt",
+		contextInput: (_request, nuxtEvent) => ({ nuxtEvent }),
+		...options.onError === void 0 ? {} : { onError: ({ handlerContext, ...input }) => options.onError?.({
+			...input,
+			nuxtEvent: handlerContext
+		}) }
+	});
+	return async (nuxtEvent) => {
+		const request = toWebRequest(nuxtEvent);
+		if (request.method !== "HEAD") return handler(request, nuxtEvent);
+		const response = await handler(new Request(request, { method: "GET" }), nuxtEvent);
+		return new Response(null, response);
+	};
+}
+let nuxtAdapterValue;
+function createNuxtAdapter(defaults) {
+	return createServerAdapter("nuxt", { mount: (implementation, options) => createRouteHandler(implementation, options === void 0 ? defaults : {
+		...defaults,
+		...options
+	}) });
+}
+/** Creates a Nuxt adapter with native Nitro request-event context and mounting operations. */
+function nuxtAdapter(options) {
+	if (options !== void 0) return createNuxtAdapter({ ...options });
+	nuxtAdapterValue ??= createNuxtAdapter({});
+	return nuxtAdapterValue;
+}
+
+//#endregion
+export { nuxtAdapter };

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@hulla/api-nuxt",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "Nuxt and Nitro integration for @hulla/api",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hulladev/api.git",
+    "directory": "packages/nuxt"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "clean": "rm -rf dist coverage .nuxt .output",
+    "test": "bun run build && vitest run",
+    "test:coverage": "bun run build && vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "h3": "^1.15.4",
+    "ofetch": "^1.5.1"
+  },
+  "devDependencies": {
+    "@hulla/api": "2.0.0",
+    "nuxt": "^4.5.2",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@hulla/api": "^2.0.0",
+    "nuxt": "^3.0.0 || ^4.0.0"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}

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.