@hulla/api-google-cloud-functions 0.0.0-stage → 2.0.0

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { FetchServerErrorInput } from "@hulla/api/fetch";
+import { Awaitable, ServerAdapter, ServerContextInput, ServerExecutableFor } from "@hulla/api/server";
+import { HttpFunction, Request as Request$1, Response as Response$1 } from "@google-cloud/functions-framework";
+import { Contract } from "@hulla/api";
+//#region src/index.d.ts
+type GoogleCloudFunction = HttpFunction;
+type GoogleCloudFunctionsRequest = Request$1;
+type GoogleCloudFunctionsResponse = Response$1;
+type GoogleCloudFunctionsAdapterContext = {
+  /** The Web request consumed by the shared Fetch executor. */
+  readonly request: Request;
+  /** The native Functions Framework request, including `rawBody` and execution metadata. */
+  readonly googleRequest: GoogleCloudFunctionsRequest;
+  readonly response: GoogleCloudFunctionsResponse;
+};
+type GoogleCloudFunctionsContextInput<ContractType extends Contract> = ServerContextInput<ContractType> & GoogleCloudFunctionsAdapterContext;
+type GoogleCloudFunctionsServerErrorInput = Omit<FetchServerErrorInput<GoogleCloudFunctionsAdapterContext>, 'handlerContext'> & GoogleCloudFunctionsAdapterContext;
+type GoogleCloudFunctionsAdapterOptions = {
+  readonly onError?: (input: GoogleCloudFunctionsServerErrorInput) => Awaitable<Response | undefined | void>;
+};
+type GoogleCloudFunctionsMountOptions = GoogleCloudFunctionsAdapterOptions;
+type GoogleCloudFunctionsMount = {
+  <const ContractType extends Contract, const Context extends object>(implementation: ServerExecutableFor<ContractType, Context, 'google-cloud-functions', GoogleCloudFunctionsAdapterContext>, options?: GoogleCloudFunctionsMountOptions): GoogleCloudFunction;
+};
+type GoogleCloudFunctionsAdapter = ServerAdapter<'google-cloud-functions', GoogleCloudFunctionsAdapterContext> & {
+  readonly mount: GoogleCloudFunctionsMount;
+};
+declare function googleCloudFunctionsAdapter(options?: GoogleCloudFunctionsAdapterOptions): GoogleCloudFunctionsAdapter;
+//#endregion
+export { GoogleCloudFunction, GoogleCloudFunctionsAdapter, GoogleCloudFunctionsAdapterContext, GoogleCloudFunctionsAdapterOptions, GoogleCloudFunctionsContextInput, GoogleCloudFunctionsMountOptions, GoogleCloudFunctionsRequest, GoogleCloudFunctionsResponse, GoogleCloudFunctionsServerErrorInput, googleCloudFunctionsAdapter };

package/dist/index.js

@@ -0,0 +1,135 @@
+import { createFetchHandler } from "@hulla/api/fetch";
+import { createServerAdapter } from "@hulla/api/server";
+
+//#region src/index.ts
+function getFirstHeaderValue(value) {
+	return typeof value === "string" ? value : value?.[0];
+}
+function createRequestHeaders(request) {
+	const headers = new Headers();
+	for (const [name, value] of Object.entries(request.headers)) {
+		if (name.startsWith(":")) continue;
+		if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+		else if (value !== void 0) headers.set(name, value);
+	}
+	return headers;
+}
+function createRequestUrl(request) {
+	const originalUrl = request.originalUrl || request.url || "/";
+	if (/^https?:\/\//i.test(originalUrl)) return originalUrl;
+	return `${getFirstHeaderValue(request.headers["x-forwarded-proto"])?.split(",")[0]?.trim() || request.protocol || "http"}://${request.get?.("host") || request.headers.host || "localhost"}${originalUrl.startsWith("/") ? originalUrl : `/${originalUrl}`}`;
+}
+function getRequestBody(request) {
+	if (request.rawBody !== void 0) return request.rawBody;
+	const body = request.body;
+	if (body === void 0 || body === null) return void 0;
+	if (typeof body === "string" || body instanceof ArrayBuffer || body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams || body instanceof Uint8Array) return body;
+	return JSON.stringify(body);
+}
+function createWebRequest(request, method) {
+	const headers = createRequestHeaders(request);
+	const body = method === "GET" || method === "HEAD" ? void 0 : getRequestBody(request);
+	if (request.rawBody === void 0 && body !== void 0) headers.delete("content-length");
+	const init = {
+		method,
+		headers,
+		...body === void 0 ? {} : { body },
+		...request.abortController === void 0 ? {} : { signal: request.abortController.signal }
+	};
+	return new Request(createRequestUrl(request), init);
+}
+function waitForDrain(response) {
+	return new Promise((resolve, reject) => {
+		const onDrain = () => {
+			cleanup();
+			resolve();
+		};
+		const onClose = () => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error("The Google Cloud Functions response closed early."));
+		};
+		const cleanup = () => {
+			response.off("drain", onDrain);
+			response.off("close", onClose);
+		};
+		response.once("drain", onDrain);
+		response.once("close", onClose);
+	});
+}
+function setResponseHeaders(source, response) {
+	const setCookies = source.getSetCookie();
+	source.forEach((value, name) => {
+		if (name !== "set-cookie") response.setHeader(name, value);
+	});
+	if (setCookies.length > 0) response.setHeader("set-cookie", setCookies);
+}
+async function writeWebResponse(source, response, suppressBody) {
+	response.statusCode = source.status;
+	setResponseHeaders(source.headers, response);
+	if (suppressBody || source.body === null) {
+		await source.body?.cancel();
+		response.end();
+		return;
+	}
+	const reader = source.body.getReader();
+	try {
+		while (true) {
+			const chunk = await reader.read();
+			if (chunk.done) break;
+			if (!response.write(chunk.value)) await waitForDrain(response);
+		}
+		response.end();
+	} catch (error) {
+		await reader.cancel(error).catch(() => void 0);
+		throw error;
+	} finally {
+		reader.releaseLock();
+	}
+}
+function failTransport(error, response) {
+	if (response.writableEnded) return;
+	if (response.headersSent) {
+		response.destroy(error instanceof Error ? error : void 0);
+		return;
+	}
+	response.statusCode = 500;
+	response.setHeader("content-type", "text/plain; charset=utf-8");
+	response.end("Internal Server Error");
+}
+function createGoogleCloudFunctionsHandler(implementation, options) {
+	const handler = createFetchHandler(implementation, {
+		contextAdapter: "google-cloud-functions",
+		contextInput: (_request, context) => context,
+		...options.onError === void 0 ? {} : { onError: ({ handlerContext, ...input }) => options.onError?.({
+			...input,
+			googleRequest: handlerContext.googleRequest,
+			response: handlerContext.response
+		}) }
+	});
+	return async (request, response) => {
+		try {
+			const webRequest = createWebRequest(request, request.method === "HEAD" ? "GET" : request.method);
+			await writeWebResponse(await handler(webRequest, {
+				googleRequest: request,
+				response
+			}), response, request.method === "HEAD");
+		} catch (error) {
+			failTransport(error, response);
+		}
+	};
+}
+let googleCloudFunctionsAdapterValue;
+function createGoogleCloudFunctionsAdapter(defaults) {
+	return createServerAdapter("google-cloud-functions", { mount: (implementation, options) => createGoogleCloudFunctionsHandler(implementation, options === void 0 ? defaults : {
+		...defaults,
+		...options
+	}) });
+}
+function googleCloudFunctionsAdapter(options) {
+	if (options !== void 0) return createGoogleCloudFunctionsAdapter({ ...options });
+	googleCloudFunctionsAdapterValue ??= createGoogleCloudFunctionsAdapter({});
+	return googleCloudFunctionsAdapterValue;
+}
+
+//#endregion
+export { googleCloudFunctionsAdapter };

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@hulla/api-google-cloud-functions",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "Google Cloud Run functions HTTP adapter for @hulla/api",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hulladev/api.git",
+    "directory": "packages/google-cloud-functions"
+  },
+  "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": "bun run build && vitest run",
+    "test:coverage": "bun run build && vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@google-cloud/functions-framework": "^5.0.5",
+    "@hulla/api": "2.0.0",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@google-cloud/functions-framework": "^5.0.0",
+    "@hulla/api": "^2.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.