@hulla/api-elysia 0.0.0-stage → 2.0.1

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import { AdapterErrorInput } from "@hulla/api/adapters";
+import { Awaitable, ServerAdapter, ServerContextInput, ServerExecutableFor } from "@hulla/api/server";
+import { Contract } from "@hulla/api";
+import Elysia, { AnyElysia, InferContext } from "elysia";
+//#region src/index.d.ts
+type ElysiaContext<App extends AnyElysia = Elysia> = Omit<InferContext<App>, 'params'> & {
+  readonly params: Readonly<Record<string, string>>;
+};
+type ElysiaAdapterContext<App extends AnyElysia> = {
+  readonly request: Request;
+  readonly elysiaContext: ElysiaContext<App>;
+};
+type ElysiaContextInput<ContractType extends Contract = Contract, App extends AnyElysia = Elysia> = ServerContextInput<ContractType> & ElysiaAdapterContext<App>;
+type ElysiaServerErrorInput<App extends AnyElysia = Elysia> = Omit<AdapterErrorInput, 'defaultResponse' | 'hostContext' | 'request'> & ElysiaAdapterContext<App> & {
+  readonly defaultResponse: Response;
+};
+type ElysiaServerOptions<App extends AnyElysia = Elysia> = {
+  readonly preserveRequestBody?: boolean;
+  /** Optional byte limit for adapter-owned body reads. Defaults to Infinity; host limits still apply. */
+  readonly maxBodyBytes?: number;
+  readonly onError?: ((input: ElysiaServerErrorInput<App>) => Awaitable<Response | undefined | void>) | undefined;
+};
+type ElysiaAdapter<App extends AnyElysia = Elysia> = ServerAdapter<'elysia', ElysiaAdapterContext<App>> & {
+  readonly mount: <const ContractType extends Contract, const Context extends object>(implementation: ServerExecutableFor<ContractType, Context, 'elysia', ElysiaAdapterContext<App>>, options?: ElysiaServerOptions<App>) => App;
+};
+/** Creates an Elysia adapter bound to one caller-owned application. */
+declare function elysiaAdapter<const App extends AnyElysia>(app: App, defaults?: ElysiaServerOptions<App>): ElysiaAdapter<App>;
+//#endregion
+export { ElysiaAdapter, ElysiaContext, ElysiaContextInput, ElysiaServerErrorInput, ElysiaServerOptions, elysiaAdapter };

package/dist/index.js

@@ -0,0 +1,103 @@
+import { bodyLimit, createAdapterRuntime, readFetchBody, toFetchResponse, writeFetchResponse } from "@hulla/api/adapters";
+import { assertAdapterContext, createServerAdapter, serverContextAdapterId } from "@hulla/api/server";
+
+//#region src/index.ts
+function requestQuery(url) {
+	const start = url.indexOf("?");
+	if (start === -1) return void 0;
+	const hash = url.indexOf("#", start + 1);
+	return new URLSearchParams(url.slice(start + 1, hash === -1 ? void 0 : hash));
+}
+function parsedBody(context, representation) {
+	const value = context["body"];
+	switch (representation) {
+		case "json":
+		case "text": return value;
+		case "bytes":
+			if (value instanceof Uint8Array) return value;
+			if (value instanceof ArrayBuffer) return new Uint8Array(value);
+			throw new TypeError("Parsed Elysia byte request body must be ArrayBuffer or Uint8Array");
+		case "form-data":
+			if (value instanceof FormData) return value;
+			throw new TypeError("Parsed Elysia form data request body must be FormData");
+		default: throw new TypeError(`Unsupported Elysia request body representation ${representation}`);
+	}
+}
+async function readBody(nativeContext, representation, preserveRequest, limit) {
+	if (nativeContext.request.bodyUsed) return parsedBody(nativeContext.elysiaContext, representation);
+	return readFetchBody(nativeContext.request, representation, preserveRequest, limit);
+}
+function requestHeaders(request) {
+	return Object.fromEntries(request.headers.entries());
+}
+function replacementResponse(response) {
+	return {
+		status: response.status,
+		headers: {},
+		body: {
+			kind: "raw",
+			value: response
+		}
+	};
+}
+function readHeader(name) {
+	return this.request.headers.get(name) ?? void 0;
+}
+function createRouteHandler(route, usesNativeContext, includeHostContext, options) {
+	const limit = bodyLimit(options.maxBodyBytes);
+	return async (elysiaContext) => {
+		const request = elysiaContext.request;
+		const query = requestQuery(request.url);
+		const nativeContext = {
+			request,
+			elysiaContext
+		};
+		const input = {
+			request,
+			signal: request.signal,
+			preserveRequestBody: options.preserveRequestBody ?? false,
+			...usesNativeContext ? { contextInput: nativeContext } : {},
+			params: elysiaContext.params,
+			...query === void 0 ? {} : { query },
+			readHeaders: () => requestHeaders(request),
+			readHeader,
+			readBody: (representation, preserveRequest) => readBody(nativeContext, representation, preserveRequest, limit),
+			...includeHostContext ? { hostContext: nativeContext } : {}
+		};
+		return writeFetchResponse(await route.execute(input), options.onError === void 0 ? void 0 : (error) => options.onError?.({
+			...error,
+			...nativeContext,
+			route: {
+				key: route.key,
+				method: route.method,
+				path: route.path
+			}
+		}));
+	};
+}
+function mountElysia(app, implementation, options) {
+	assertAdapterContext(implementation.context, "elysia");
+	const usesNativeContext = serverContextAdapterId(implementation.context) !== void 0;
+	const runtime = createAdapterRuntime(implementation, options.onError === void 0 ? {} : { onError: async ({ hostContext, ...input }) => {
+		const nativeContext = hostContext;
+		const replacement = await options.onError?.({
+			...input,
+			...nativeContext,
+			defaultResponse: toFetchResponse(input.defaultResponse).clone()
+		});
+		return replacement instanceof Response ? replacementResponse(replacement) : void 0;
+	} });
+	for (const route of runtime.routes) app.route(route.method, route.path, createRouteHandler(route, usesNativeContext, options.onError !== void 0, options));
+	return app;
+}
+/** Creates an Elysia adapter bound to one caller-owned application. */
+function elysiaAdapter(app, defaults = {}) {
+	const configuredDefaults = { ...defaults };
+	return createServerAdapter("elysia", { mount: (implementation, options) => mountElysia(app, implementation, options === void 0 ? configuredDefaults : {
+		...configuredDefaults,
+		...options
+	}) });
+}
+
+//#endregion
+export { elysiaAdapter };

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@hulla/api-elysia",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.1",
+  "description": "Elysia server adapter for @hulla/api implementations",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hulladev/api.git",
+    "directory": "packages/elysia"
+  },
+  "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"
+  },
+  "devDependencies": {
+    "@hulla/api": "2.0.1",
+    "elysia": "^1.4.29",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@hulla/api": "^2.0.1",
+    "elysia": "^1.4.0"
+  }
+}

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.