@alteran/astro 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alteran/astro",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Astro integration for running a Cloudflare-hosted Bluesky PDS with Alteran.",
   "module": "index.js",
   "types": "index.d.ts",

package/src/worker/runtime.ts

@@ -1,8 +1,7 @@
-import { handle } from 'astro/internal/handler';
-import { onRequest } from '../middleware';
 import { seed } from '../db/seed';
 import { validateConfigOrThrow } from '../lib/config';
 import type { Env } from '../env';
+import type { SSRManifest } from 'astro';
 import type {
   ExecutionContext,
   Request as WorkersRequest,
@@ -15,11 +14,19 @@ export type PdsFetchHandler = (
   ctx: ExecutionContext
 ) => Promise<WorkersResponse>;
 
+export interface CreatePdsFetchHandlerOptions {
+  /**
+   * Optionally pass the host project's manifest when composing the worker manually.
+   * When omitted, the integration will load the manifest lazily from the build output.
+   */
+  manifest?: SSRManifest;
+}
+
 /**
  * Returns the Alteran PDS Worker fetch handler so downstream apps can
  * compose it inside their own Cloudflare Worker entrypoint.
  */
-export function createPdsFetchHandler(): PdsFetchHandler {
+export function createPdsFetchHandler(options?: CreatePdsFetchHandlerOptions): PdsFetchHandler {
   return async function fetch(request: WorkersRequest, env: Env, ctx: ExecutionContext) {
     try {
       validateConfigOrThrow(env);
@@ -53,11 +60,41 @@ export function createPdsFetchHandler(): PdsFetchHandler {
       return (await stub.fetch(request as any)) as unknown as WorkersResponse;
     }
 
-    const locals: any = { runtime: { env, ctx, request } };
-    return (await onRequest(locals as any, async () => await handle(locals as any))) as unknown as WorkersResponse;
+    const astroFetch = await getAstroFetch(options);
+    const response = await astroFetch(request, env as any, ctx);
+    return response as unknown as WorkersResponse;
   };
 }
 
-export { onRequest };
+type AstroFetchHandler = (
+  request: WorkersRequest,
+  env: Env,
+  ctx: ExecutionContext
+) => Promise<WorkersResponse>;
+
+let cachedFetchPromise: Promise<AstroFetchHandler> | undefined;
+
+async function loadAstroFetchFromManifest(manifest: SSRManifest): Promise<AstroFetchHandler> {
+  const { createExports } = await import('@astrojs/cloudflare/entrypoints/server.js');
+  const exports = createExports(manifest);
+  return exports.default.fetch as unknown as AstroFetchHandler;
+}
+
+async function getAstroFetch(options?: CreatePdsFetchHandlerOptions): Promise<AstroFetchHandler> {
+  if (options?.manifest) {
+    return loadAstroFetchFromManifest(options.manifest);
+  }
+
+  if (!cachedFetchPromise) {
+    cachedFetchPromise = (async () => {
+      const { manifest } = await import('@astrojs-manifest');
+      return loadAstroFetchFromManifest(manifest as SSRManifest);
+    })();
+  }
+
+  return cachedFetchPromise;
+}
+
+export { onRequest } from '../middleware';
 export { seed };
 export { validateConfigOrThrow };

package/types/astro-manifest.d.ts

@@ -0,0 +1,6 @@
+import type { SSRManifest } from 'astro';
+
+declare module '@astrojs-manifest' {
+  export const manifest: SSRManifest;
+  export default manifest;
+}

package/types/worker.d.ts

@@ -1,4 +1,8 @@
-export { createPdsFetchHandler, type PdsFetchHandler } from '../src/worker/runtime';
+export {
+  createPdsFetchHandler,
+  type PdsFetchHandler,
+  type CreatePdsFetchHandlerOptions,
+} from '../src/worker/runtime';
 export { Sequencer } from '../src/worker/sequencer';
 export { onRequest } from '../src/middleware';
 export { seed } from '../src/db/seed';