@depot/connectrpc-workers/dist/index.js

Connect RPC adapter for Cloudflare Workers

// src/index.ts
import { createConnectRouter } from "@connectrpc/connect";
import { uResponseNotFound } from "@connectrpc/connect/protocol";
function connectWorkersAdapter(options) {
  const router = createConnectRouter(options);
  options.routes(router);
  const paths = /* @__PURE__ */ new Map();
  const prefix = options.requestPathPrefix ?? "";
  for (const handler2 of router.handlers) {
    paths.set(prefix + handler2.requestPath, handler2);
  }
  const notFoundResponse = universalResponseToResponse(uResponseNotFound);
  const handler = async (request, env, context) => {
    const handler2 = paths.get(new URL(request.url).pathname);
    if (!handler2) return options.fallback ? options.fallback(request, env, context) : notFoundResponse;
    const contextValues = options.contextValues?.(request, env, context);
    const universalRequest = requestToUniversalRequest(request, contextValues);
    const universalResponse = await handler2(universalRequest);
    return universalResponseToResponse(universalResponse);
  };
  return handler;
}
function requestToUniversalRequest(request, contextValues) {
  const httpVersion = request.cf?.httpProtocol === "HTTP/2" ? "2.0" : "1.1";
  return {
    httpVersion,
    url: request.url,
    method: request.method,
    header: request.headers,
    body: request.body,
    signal: request.signal,
    contextValues
  };
}
function universalResponseToResponse(universalResponse) {
  if (universalResponse.trailer) {
    console.warn("Trailers are not supported in the Workers environment, and will be ignored by the Response");
  }
  return new Response(universalResponse.body ? asyncIterableToReadableStream(universalResponse.body) : null, {
    status: universalResponse.status,
    headers: universalResponse.header
  });
}
function asyncIterableToReadableStream(iterable) {
  return new ReadableStream({
    async start(controller) {
      try {
        for await (const chunk of iterable) {
          controller.enqueue(chunk);
        }
        controller.close();
      } catch (err) {
        controller.error(err);
      }
    }
  });
}
export {
  connectWorkersAdapter
};