@tschk/moonshine-deploy-node 0.4.1 → 0.4.4

package/README.md

@@ -11,6 +11,13 @@ await nodeAdapter.build(manifest, ".moonshine");
 - Target runtime: `node`.
 - Capabilities: `streaming`, `islands`, `revalidation`.
 - Output: `server.ts` using `node:http` and a `Request` / `Response` bridge.
+- Native builds also emit a bundled `server.js`; deploy it beside `public/` and run
+  `node server.js`. The bundle includes its manifest and needs no runtime packages.
+  This path is verified on Node 22. Building still requires Bun.
+
+Create an independent native app with `moonshine new app --adapter node`, then
+run `bun install`, `bun run build`, and `bun run start`. Native Node supports SSR,
+static rendering, and explicit SPA clients; hydration and streaming are unfinished.
 
 See [docs/DEPLOYMENT.md](../../docs/DEPLOYMENT.md) and
 [docs/MANIFEST.md](../../docs/MANIFEST.md).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tschk/moonshine-deploy-node",
-  "version": "0.4.1",
+  "version": "0.4.4",
   "license": "ISC",
   "type": "module",
   "main": "./src/index.ts",
@@ -15,18 +15,24 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@tschk/moonshine-compiler": "^0.4.1",
-    "@tschk/moonshine-framework": "^0.4.1",
-    "@tschk/moonshine-react": "^0.4.1",
-    "@tschk/moonshine-server": "^0.4.1"
+    "@tschk/moonshine-framework": "^0.4.4",
+    "@tschk/moonshine-server": "^0.4.4"
   },
   "devDependencies": {
     "@types/bun": "1.3.14",
     "@types/node": "^22.0.0",
     "typescript": "7.0.2",
-    "@tschk/moonshine-adapter-conformance": "^0.4.1"
+    "@tschk/moonshine-adapter-conformance": "^0.4.4"
   },
   "files": [
     "src"
-  ]
+  ],
+  "peerDependencies": {
+    "@tschk/moonshine-react": "^0.4.4"
+  },
+  "peerDependenciesMeta": {
+    "@tschk/moonshine-react": {
+      "optional": true
+    }
+  }
 }

package/src/index.ts

@@ -1,23 +1,20 @@
-import { createReadStream } from "node:fs";
-import { copyFile, mkdir, stat, writeFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import {
   createServer,
   type IncomingMessage,
   type ServerResponse,
 } from "node:http";
-import { dirname, isAbsolute, resolve } from "node:path";
+import { resolve } from "node:path";
 import { Readable } from "node:stream";
 import {
   type DeploymentAdapter,
   type MoonshineManifest,
   type Harness,
   type HarnessFactory,
+  copyAsset,
+  validateRuntime,
 } from "@tschk/moonshine-framework";
-import {
-  isContained,
-  resolveStaticPath,
-  staticFileHeaders,
-} from "@tschk/moonshine-server";
+import { tryServeStatic } from "@tschk/moonshine-server";
 
 const HOP_BY_HOP = new Set([
   "connection",
@@ -35,67 +32,17 @@ function isHopByHopHeader(key: string): boolean {
   return HOP_BY_HOP.has(key.toLowerCase());
 }
 
-const MIME: Record<string, string> = {
-  ".css": "text/css; charset=utf-8",
-  ".gif": "image/gif",
-  ".html": "text/html; charset=utf-8",
-  ".ico": "image/x-icon",
-  ".jpeg": "image/jpeg",
-  ".jpg": "image/jpeg",
-  ".js": "text/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".map": "application/json; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".png": "image/png",
-  ".svg": "image/svg+xml",
-  ".txt": "text/plain; charset=utf-8",
-  ".wasm": "application/wasm",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-};
-
-function extOf(path: string): string {
-  const i = path.lastIndexOf(".");
-  return i >= 0 ? path.slice(i).toLowerCase() : "";
-}
-
-async function tryServeNodeStatic(
-  staticDir: string,
-  pathname: string,
-): Promise<Response | null> {
-  const filePath = resolveStaticPath(staticDir, pathname);
-  if (!filePath) return null;
-  let stats = null;
-  try {
-    stats = await stat(filePath);
-  } catch {
-    return null;
-  }
-  if (!stats.isFile()) return null;
-  try {
-    if (!isContained(staticDir, filePath)) return null;
-  } catch {
-    return null;
-  }
-  const type = MIME[extOf(filePath)] ?? "application/octet-stream";
-  const stream = createReadStream(filePath);
-  const headers = staticFileHeaders(type);
-  headers.set("content-length", String(stats.size));
-  return new Response(Readable.toWeb(stream) as unknown as ReadableStream, {
-    headers,
-  });
-}
-
 async function sendNodeResponse(
   res: ServerResponse,
   response: Response,
 ): Promise<void> {
-  const headers: Record<string, string> = {};
+  const headers: Record<string, string | string[]> = {};
   for (const [key, value] of response.headers.entries()) {
-    if (isHopByHopHeader(key)) continue;
+    if (isHopByHopHeader(key) || key.toLowerCase() === "set-cookie") continue;
     headers[key] = value;
   }
+  const cookies = response.headers.getSetCookie();
+  if (cookies.length > 0) headers["set-cookie"] = cookies;
   res.writeHead(response.status, headers);
   if (!response.body) {
     res.end();
@@ -142,7 +89,12 @@ export function createNodeHandler(
       (method === "GET" || method === "HEAD") &&
       pathname !== "/"
     ) {
-      const staticRes = await tryServeNodeStatic(options.staticDir, pathname);
+      const staticRes = await tryServeStatic(
+        options.staticDir,
+        pathname,
+        undefined,
+        method,
+      );
       if (staticRes) {
         await sendNodeResponse(res, staticRes);
         return;
@@ -224,29 +176,12 @@ export const nodeHarness: HarnessFactory = (fetch, options) => {
   } as Harness;
 };
 
-async function copyAsset(
-  asset: MoonshineManifest["assets"][number],
-  outDir: string,
-): Promise<string> {
-  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);
-  }
-  return (asset.path ?? asset.file).replace(/^\/+/, "");
-}
-
 export const nodeAdapter: DeploymentAdapter = {
   name: "node",
   runtimes: ["node"],
   capabilities: ["streaming", "islands", "revalidation"],
   build: async (manifest, outDir) => {
+    validateRuntime(nodeAdapter, manifest);
     await mkdir(outDir, { recursive: true });
     const assets = await Promise.all(
       manifest.assets.map(async (asset) => {
@@ -259,15 +194,21 @@ export const nodeAdapter: DeploymentAdapter = {
       resolve(outDir, "manifest.json"),
       JSON.stringify(builtManifest, null, 2) + "\n",
     );
+    const native = manifest.renderer === "native";
+    const rendererImport = native
+      ? 'import { modules, renderer } from "./dist/server.js";'
+      : 'import { modules } from "./dist/server.js";\nimport { reactRenderer as renderer } from "@tschk/moonshine-react";';
     const entry = `import { createServer } from "node:http";
 import { createRequestHandler } from "@tschk/moonshine-server";
-import { reactRenderer } from "@tschk/moonshine-react";
 import { createNodeHandler } from "@tschk/moonshine-deploy-node";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import manifest from "./manifest.json" with { type: "json" };
-import { modules } from "./dist/server.js";
+${rendererImport}
+${manifest.requestContext ? 'import { requestScope } from "./dist/server.js";' : ""}
 
-const projectDir = resolve(import.meta.dir, "..");
+const artifactDir = dirname(fileURLToPath(import.meta.url));
+const projectDir = resolve(artifactDir, "..");
 const abs = (p) => (p ? resolve(projectDir, p) : undefined);
 const resolvedManifest = {
   ...manifest,
@@ -282,17 +223,33 @@ const resolvedManifest = {
 };
 
 const fetch = createRequestHandler({
-  manifest: resolvedManifest,
+  manifest: ${native ? "manifest" : "resolvedManifest"},
   modules,
-  renderer: reactRenderer,
-  staticDir: import.meta.dir + "/public",
+  renderer,${manifest.requestContext ? "\n  requestScope," : ""}
+  staticDir: artifactDir + "/public",
 });
-const server = createServer(createNodeHandler({ fetch, staticDir: import.meta.dir + "/public" }));
-server.listen(Number(process.env.PORT) || 0, () => {
+export const server = createServer(createNodeHandler({ fetch }));
+const envPort = Number(process.env.PORT);
+server.listen(Number.isInteger(envPort) && envPort >= 0 && envPort <= 65535 ? envPort : 0, () => {
   const address = server.address();
   const port = typeof address === "object" && address ? address.port : 0;
+  console.log("http://localhost:" + port + "/");
 });
 `;
-    await writeFile(resolve(outDir, "server.ts"), entry);
+    const entryPath = resolve(outDir, "server.ts");
+    await writeFile(entryPath, entry);
+    if (native) {
+      const result = await Bun.build({
+        entrypoints: [entryPath],
+        outdir: outDir,
+        target: "node",
+        packages: "bundle",
+      });
+      if (!result.success)
+        throw new AggregateError(
+          result.logs,
+          "Native Node server bundle failed",
+        );
+    }
   },
 };