@hulla/api-astro 0.0.0-stage → 2.0.1

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { FetchServerErrorInput } from "@hulla/api/fetch";
+import { Awaitable, ServerAdapter, ServerContextInput, ServerExecutableFor } from "@hulla/api/server";
+import { Contract } from "@hulla/api";
+import { ClientTransport } from "@hulla/api/client";
+import { APIContext, APIRoute } from "astro";
+//#region src/server.d.ts
+type AstroContext = APIContext;
+type AstroRouteHandler = APIRoute;
+type AstroAdapterContext = {
+  readonly request: Request;
+  readonly astroContext: AstroContext;
+};
+type AstroServerErrorInput = Omit<FetchServerErrorInput<AstroContext>, 'handlerContext'> & {
+  readonly astroContext: AstroContext;
+};
+type AstroServerOptions = {
+  readonly onError?: ((input: AstroServerErrorInput) => Awaitable<Response | undefined | void>) | undefined;
+};
+type AstroContextInput<ContractType extends Contract = Contract> = ServerContextInput<ContractType> & AstroAdapterContext;
+type AstroAdapter = ServerAdapter<'astro', AstroAdapterContext> & {
+  readonly mount: <const ContractType extends Contract, const Context extends object>(implementation: ServerExecutableFor<ContractType, Context, 'astro', AstroAdapterContext>, options?: AstroServerOptions) => AstroRouteHandler;
+};
+/**
+ * Creates a zero-network client transport for an Astro page, endpoint, or server island.
+ *
+ * The explicit context is the current Astro render context. Inside a server island its request URL identifies Astro's
+ * internal island endpoint rather than the page that contains the island.
+ */
+declare function astroInProcessTransport<const ContractType extends Contract, const Context extends object>(implementation: ServerExecutableFor<ContractType, Context, 'astro', AstroAdapterContext>, astroContext: AstroContext): ClientTransport;
+/** Creates an Astro adapter with native render-context access and endpoint mounting operations. */
+declare function astroAdapter(options?: AstroServerOptions): AstroAdapter;
+//#endregion
+export { type AstroAdapter, type AstroAdapterContext, type AstroContext, type AstroContextInput, type AstroRouteHandler, type AstroServerErrorInput, type AstroServerOptions, astroAdapter, astroInProcessTransport };

package/dist/index.js

@@ -0,0 +1,78 @@
+import { createAdapterHandler } from "@hulla/api/adapters";
+import { createFetchHandler } from "@hulla/api/fetch";
+import { assertAdapterContext, createServerAdapter, serverContextAdapterId } from "@hulla/api/server";
+
+//#region src/server.ts
+/** Creates an Astro API route backed by an @hulla/api server implementation. */
+function createRouteHandler(implementation, options = {}) {
+	const handler = createFetchHandler(implementation, {
+		contextAdapter: "astro",
+		contextInput: (_request, astroContext) => ({ astroContext }),
+		...options.onError === void 0 ? {} : { onError: ({ handlerContext, ...input }) => options.onError?.({
+			...input,
+			astroContext: handlerContext
+		}) }
+	});
+	return async (astroContext) => {
+		const request = astroContext.request;
+		if (request.method !== "HEAD") return handler(request, astroContext);
+		const response = await handler(new Request(request, { method: "GET" }), astroContext);
+		return new Response(null, response);
+	};
+}
+function inProcessResponse(response) {
+	return {
+		status: response.status,
+		headers: response.headers,
+		native: response,
+		readBody: (kind) => {
+			if (response.body.kind !== kind) throw new TypeError(`Astro in-process response body is ${response.body.kind}, but the client selected ${kind}`);
+			return response.body.value;
+		}
+	};
+}
+/**
+* Creates a zero-network client transport for an Astro page, endpoint, or server island.
+*
+* The explicit context is the current Astro render context. Inside a server island its request URL identifies Astro's
+* internal island endpoint rather than the page that contains the island.
+*/
+function astroInProcessTransport(implementation, astroContext) {
+	assertAdapterContext(implementation.context, "astro");
+	const usesAstroContext = serverContextAdapterId(implementation.context) === "astro";
+	const dispatch = createAdapterHandler(implementation);
+	return async (request) => {
+		request.signal?.throwIfAborted();
+		return inProcessResponse(await dispatch({
+			request: astroContext.request,
+			...usesAstroContext ? { contextInput: {
+				request: astroContext.request,
+				astroContext
+			} } : {},
+			method: request.method,
+			pathname: request.path,
+			headers: request.headers,
+			...request.query === void 0 ? {} : { query: request.query },
+			...request.body === void 0 ? {} : { body: {
+				value: request.body.value,
+				contentType: request.body.contentType
+			} }
+		}));
+	};
+}
+let astroAdapterValue;
+function createAstroAdapter(defaults) {
+	return createServerAdapter("astro", { mount: (implementation, options) => createRouteHandler(implementation, options === void 0 ? defaults : {
+		...defaults,
+		...options
+	}) });
+}
+/** Creates an Astro adapter with native render-context access and endpoint mounting operations. */
+function astroAdapter(options) {
+	if (options !== void 0) return createAstroAdapter({ ...options });
+	astroAdapterValue ??= createAstroAdapter({});
+	return astroAdapterValue;
+}
+
+//#endregion
+export { astroAdapter, astroInProcessTransport };

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@hulla/api-astro",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.1",
+  "description": "Astro endpoint and server-island integration for @hulla/api",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hulladev/api.git",
+    "directory": "packages/astro"
+  },
+  "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 .astro",
+    "test": "bun run build && vitest run",
+    "test:coverage": "bun run build && vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@astrojs/node": "^11.0.0",
+    "@hulla/api": "2.0.1",
+    "astro": "^7.0.0",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@hulla/api": "^2.0.1",
+    "astro": "^5.0.0 || ^6.0.0 || ^7.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.