@recranet/astro-workers-for-platforms-adapter 1.0.0

package/README.md

@@ -0,0 +1 @@
+# astro-workers-for-platforms-adapter

package/adapter.mjs

@@ -0,0 +1,58 @@
+// Custom Astro adapter for Cloudflare Workers for Platforms.
+//
+// Architecture:
+//   Request → Dispatch Worker → User Worker (worker-entry.mjs) → env.ASSETS.fetch()
+//
+// This adapter ensures Astro always emits a worker entry, even for fully static sites.
+// While static assets could be uploaded to R2 and served by the dispatch worker,
+// Workers for Platforms supports a native Static Assets binding (env.ASSETS) that
+// serves files from the edge with per-tenant isolation — no R2 needed.
+//
+// The official @astrojs/cloudflare adapter cannot be used here because:
+//   - It requires wrangler as a peer dependency (we deploy via the CF API directly)
+//   - As of Astro 6 (PR #15478), it deletes the _worker.js output for fully static
+//     sites, which is the opposite of what Workers for Platforms needs
+//   - Its worker entrypoint is designed for Pages/Workers, not the dispatch namespace
+//     API with env.ASSETS binding and run_worker_first config
+//
+// Build flow:
+//   `astro build` triggers this adapter, which sets `ssr.noExternal: true` so Vite
+//   bundles all dependencies (including hono/utils/mime used in worker-entry.mjs)
+//   into a single dist/server/entry.mjs with no external imports. Static assets
+//   are prerendered into dist/client/.
+//
+// The build output (entry.mjs + static assets) is deployed by the astro-sandbox
+// worker in studio via deploy.ts, which uses the Workers for Platforms 3-step asset
+// upload API (create session → upload buckets → deploy worker with completion token).
+export default function cloudflareWorkerScriptAdapter() {
+  return {
+    name: 'cloudflare-worker-script',
+    hooks: {
+      'astro:config:setup': ({ updateConfig }) => {
+        updateConfig({
+          vite: {
+            ssr: {
+              // Bundle all dependencies into the server entry (no external imports)
+              noExternal: true,
+            },
+          },
+        });
+      },
+      'astro:config:done': ({ setAdapter }) => {
+        setAdapter({
+          name: 'cloudflare-worker-script',
+          serverEntrypoint: new URL('./worker-entry.mjs', import.meta.url),
+          previewEntrypoint: new URL('./preview-entry.mjs', import.meta.url).pathname,
+          entrypointResolution: 'auto',
+          supportedAstroFeatures: {
+            staticOutput: 'stable',
+            hybridOutput: { support: 'unsupported', message: '', suppress: 'all' },
+            serverOutput: { support: 'unsupported', message: '', suppress: 'all' },
+            sharpImageService: { support: 'unsupported', message: '', suppress: 'all' },
+            envGetSecret: 'stable',
+          },
+        });
+      },
+    },
+  };
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@recranet/astro-workers-for-platforms-adapter",
+  "version": "1.0.0",
+  "type": "module",
+  "exports": "./adapter.mjs",
+  "files": [
+    "adapter.mjs",
+    "worker-entry.mjs",
+    "preview-entry.mjs",
+    "vite-plugin-astro-preview.mjs"
+  ],
+  "peerDependencies": {
+    "astro": "^6.0.0"
+  },
+  "dependencies": {
+    "hono": "^4.12.7"
+  },
+  "scripts": {
+    "publish": "npm publish . --access public"
+  }
+}

package/preview-entry.mjs

@@ -0,0 +1,30 @@
+import { fileURLToPath } from 'node:url';
+import { preview } from 'vite';
+import { vitePluginAstroPreview } from './vite-plugin-astro-preview.mjs';
+
+export default async function createPreviewServer({ client, host, port, headers, logger }) {
+  const clientDir = fileURLToPath(client);
+
+  const previewServer = await preview({
+    configFile: false,
+    appType: 'mpa',
+    build: { outDir: clientDir },
+    preview: { host, port, headers },
+    plugins: [vitePluginAstroPreview(clientDir)],
+  });
+
+  const address = previewServer.resolvedUrls?.local?.[0] ?? `http://${host ?? 'localhost'}:${port}/`;
+  logger.info(`Preview server listening on ${address}`);
+
+  return {
+    host: host ?? 'localhost',
+    port,
+    closed: () =>
+      new Promise((resolve, reject) => {
+        previewServer.httpServer.addListener('close', resolve);
+        previewServer.httpServer.addListener('error', reject);
+      }),
+    server: previewServer.httpServer,
+    stop: previewServer.close.bind(previewServer),
+  };
+}

package/vite-plugin-astro-preview.mjs

@@ -0,0 +1,53 @@
+// Adapted from astro/dist/core/preview/vite-plugin-astro-preview.js
+// Handles clean URL routing for static builds in Vite's MPA preview server.
+import fs from 'node:fs';
+import { join } from 'node:path';
+
+export function vitePluginAstroPreview(outDir) {
+  return {
+    name: 'astro:preview',
+    apply: 'serve',
+    configurePreviewServer(server) {
+      // Replace Vite's default 404 handler with one that serves 404.html if it exists
+      server.middlewares.use((req, res, next) => {
+        for (const middleware of server.middlewares.stack) {
+          if (middleware.handle.name === 'vite404Middleware') {
+            middleware.handle = (_req, _res) => {
+              const errorPagePath = join(outDir, '404.html');
+              if (fs.existsSync(errorPagePath)) {
+                _res.statusCode = 404;
+                _res.setHeader('Content-Type', 'text/html');
+                _res.end(fs.readFileSync(errorPagePath));
+              } else {
+                _res.statusCode = 404;
+                _res.end('Not Found');
+              }
+            };
+          }
+        }
+        next();
+      });
+
+      // Post-middleware: rewrite clean URLs to their HTML files
+      return () => {
+        server.middlewares.use((req, _res, next) => {
+          const pathname = req.url?.split('?')[0];
+          if (pathname?.endsWith('/')) {
+            const htmlPath = join(outDir, pathname.slice(0, -1) + '.html');
+            if (fs.existsSync(htmlPath)) {
+              req.url = pathname.slice(0, -1) + '.html';
+              return next();
+            }
+          } else if (pathname && !pathname.includes('.')) {
+            const indexPath = join(outDir, pathname, 'index.html');
+            if (fs.existsSync(indexPath)) {
+              req.url = pathname + '/index.html';
+              return next();
+            }
+          }
+          next();
+        });
+      };
+    },
+  };
+}

package/worker-entry.mjs

@@ -0,0 +1,26 @@
+// Worker entry point for Cloudflare Workers for Platforms.
+// Serves static assets via the env.ASSETS binding provided by the dispatch namespace,
+// with fixes for missing content-type headers and cache-control.
+import { getMimeType } from 'hono/utils/mime';
+
+export default {
+  async fetch(request, env) {
+    const asset = await env.ASSETS.fetch(request);
+
+    // Clone into a mutable response so we can set headers.
+    const response = new Response(asset.body, asset);
+
+    // Prevent edge/browser caching — themes are redeployed in-place and must
+    // always reflect the latest version.
+    response.headers.set('cache-control', 'no-store');
+
+    // Workers for Platforms sometimes omits content-type on asset responses.
+    // Derive it from the file extension so browsers handle CSS, JS, etc. correctly.
+    const mimeType = getMimeType(new URL(request.url).pathname);
+    if (!response.headers.get('content-type') && mimeType) {
+      response.headers.set('content-type', mimeType);
+    }
+
+    return response;
+  },
+};