@tschk/moonshine-deploy-cloudflare 0.3.1

package/README.md

@@ -0,0 +1,20 @@
+# `@tschk/moonshine-deploy-cloudflare`
+
+Cloudflare Workers deployment adapter for Moonshine.
+
+```ts
+import { cloudflareAdapter } from "@tschk/moonshine-deploy-cloudflare";
+
+await cloudflareAdapter.build(manifest, ".moonshine");
+```
+
+- Target runtime: `cloudflare`.
+- Capabilities: `streaming`, `islands`, `edge`, `revalidation`.
+- Output: `server.ts` worker that uses the Cloudflare Cache API and an `ASSETS`
+  binding for static files.
+
+Limitations: requires an `ASSETS` binding for static files; worker size and
+Cache API limits apply.
+
+See [docs/DEPLOYMENT.md](../../docs/DEPLOYMENT.md) and
+[docs/MANIFEST.md](../../docs/MANIFEST.md).

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@tschk/moonshine-deploy-cloudflare",
+  "version": "0.3.1",
+  "license": "ISC",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "format": "bunx prettier --check .",
+    "lint": "bunx oxlint .",
+    "typecheck": "bunx tsc --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@tschk/moonshine-framework": "^0.3.1",
+    "@tschk/moonshine-server": "^0.3.1",
+    "@tschk/moonshine-router": "^0.3.1",
+    "@tschk/moonshine-compiler": "^0.3.1",
+    "@tschk/moonshine-react": "^0.3.1"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "@tschk/moonshine-adapter-conformance": "^0.3.1",
+    "typescript": "7.0.2"
+  },
+  "files": [
+    "src"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,214 @@
+import { copyFile, mkdir, writeFile } from "node:fs/promises";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { createRequestHandler, tryServeStatic } from "@tschk/moonshine-server";
+import { matchRoutes, createRouteGraph } from "@tschk/moonshine-router";
+import { reactRenderer } from "@tschk/moonshine-react";
+import type {
+  DeploymentAdapter,
+  MoonshineManifest,
+} from "@tschk/moonshine-framework";
+import type {
+  Harness,
+  HarnessFactory,
+} from "@tschk/moonshine-adapter-conformance";
+
+export type CloudflareEnv = {
+  ASSETS?: { fetch: (request: Request) => Promise<Response> };
+};
+
+export type CloudflareContext = {
+  waitUntil: (promise: Promise<unknown>) => void;
+};
+
+export async function cloudflareFetch(
+  request: Request,
+  env: CloudflareEnv,
+  ctx: CloudflareContext,
+  manifest: MoonshineManifest,
+): Promise<Response> {
+  const url = new URL(request.url);
+  const pathname = url.pathname.replace(/\/+$/, "") || "/";
+
+  if (
+    env.ASSETS &&
+    (request.method === "GET" || request.method === "HEAD") &&
+    pathname !== "/"
+  ) {
+    const assetRes = await env.ASSETS.fetch(request);
+    if (assetRes.status !== 404) return assetRes;
+  }
+
+  const graph = createRouteGraph(manifest.routes);
+  const match = matchRoutes(graph, pathname);
+  const handler = createRequestHandler({ manifest, renderer: reactRenderer });
+  const cache =
+    typeof caches !== "undefined"
+      ? (caches as { default?: Cache }).default
+      : undefined;
+
+  if (match && match.route.cache && cache) {
+    const cached = await cache.match(request);
+    if (cached) return cached;
+    const response = await handler(request);
+    if (
+      response.status >= 200 &&
+      response.status < 400 &&
+      (request.method === "GET" || request.method === "HEAD")
+    ) {
+      ctx.waitUntil(
+        (async () => {
+          try {
+            await cache.put(request.clone(), response.clone());
+          } catch {}
+        })(),
+      );
+    }
+    return response;
+  }
+
+  return handler(request);
+}
+
+export default cloudflareFetch;
+
+function resolveManifestFiles(
+  manifest: MoonshineManifest,
+  projectRoot: string,
+): MoonshineManifest {
+  return {
+    ...manifest,
+    routes: manifest.routes.map((route) => ({
+      ...route,
+      file: isAbsolute(route.file)
+        ? route.file
+        : resolve(projectRoot, route.file),
+      ...(route.dataFile && {
+        dataFile: isAbsolute(route.dataFile)
+          ? route.dataFile
+          : resolve(projectRoot, route.dataFile),
+      }),
+      ...(route.layouts && {
+        layouts: route.layouts.map((layout) =>
+          isAbsolute(layout) ? layout : resolve(projectRoot, layout),
+        ),
+      }),
+      ...(route.middleware && {
+        middleware: route.middleware.map((middleware) =>
+          isAbsolute(middleware)
+            ? middleware
+            : resolve(projectRoot, middleware),
+        ),
+      }),
+      ...(route.errorBoundary && {
+        errorBoundary: isAbsolute(route.errorBoundary)
+          ? route.errorBoundary
+          : resolve(projectRoot, route.errorBoundary),
+      }),
+    })),
+  };
+}
+
+async function copyAssets(
+  assets: MoonshineManifest["assets"],
+  outDir: string,
+): Promise<void> {
+  for (const asset of assets) {
+    const source = isAbsolute(asset.file)
+      ? asset.file
+      : resolve(outDir, asset.file);
+    const target = resolve(
+      outDir,
+      (asset.path ?? asset.file).replace(/^\/+/, ""),
+    );
+    await mkdir(dirname(target), { recursive: true });
+    if (source !== target) {
+      await copyFile(source, target);
+    }
+  }
+}
+
+function validateRuntime(
+  adapter: DeploymentAdapter,
+  manifest: MoonshineManifest,
+): void {
+  const errors: string[] = [];
+  for (const route of manifest.routes) {
+    if (!adapter.runtimes.includes(route.runtime)) {
+      errors.push(
+        `${adapter.name} adapter does not support route "${route.path}" with runtime "${route.runtime}"; supported runtimes: ${adapter.runtimes.join(", ")}`,
+      );
+    }
+  }
+  if (errors.length) throw new Error(errors.join("\n"));
+}
+
+function validateCapabilities(
+  adapter: DeploymentAdapter,
+  manifest: MoonshineManifest,
+): void {
+  for (const capability of manifest.capabilities) {
+    if (!adapter.capabilities.includes(capability)) {
+      throw new Error(
+        `${adapter.name} adapter does not support capability "${capability}"; supported capabilities: ${adapter.capabilities.join(", ")}`,
+      );
+    }
+  }
+}
+
+export const cloudflareAdapter: DeploymentAdapter = {
+  name: "cloudflare",
+  runtimes: ["cloudflare"],
+  capabilities: ["streaming", "islands", "edge", "revalidation"],
+  build: async (manifest, outDir) => {
+    validateRuntime(cloudflareAdapter, manifest);
+    validateCapabilities(cloudflareAdapter, manifest);
+
+    await mkdir(outDir, { recursive: true });
+    const projectRoot = resolve(outDir, "..");
+    const resolvedManifest = resolveManifestFiles(manifest, projectRoot);
+
+    await writeFile(
+      resolve(outDir, "manifest.json"),
+      JSON.stringify(resolvedManifest, null, 2) + "\n",
+    );
+    await copyAssets(manifest.assets, outDir);
+
+    const serverEntry = `import cloudflareFetch from "@tschk/moonshine-deploy-cloudflare";
+import manifest from "./manifest.json" with { type: "json" };
+
+type Env = { ASSETS?: { fetch: (request: Request) => Promise<Response> } };
+
+export default {
+  async fetch(request: Request, env: Env, ctx: { waitUntil: (promise: Promise<unknown>) => void }) {
+    return cloudflareFetch(request, env, ctx, manifest);
+  },
+};
+`;
+    await writeFile(resolve(outDir, "server.ts"), serverEntry);
+  },
+};
+
+export const cloudflareHarness: HarnessFactory = (fetch, options) => {
+  const server = Bun.serve({
+    port: 0,
+    fetch: async (request) => {
+      const url = new URL(request.url);
+      const pathname = url.pathname.replace(/\/+$/, "") || "/";
+      if (
+        (request.method === "GET" || request.method === "HEAD") &&
+        pathname !== "/"
+      ) {
+        const res = await tryServeStatic(options.staticDir, pathname);
+        if (res) return res;
+      }
+      return fetch(request);
+    },
+  });
+
+  return {
+    start: async () => server.url,
+    stop: async () => {
+      server.stop(true);
+    },
+  } as Harness;
+};