@jxsuite/compiler 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/compiler",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Jx static HTML compiler, island detector, and site builder",
   "license": "MIT",
   "repository": {

package/src/compiler.js

@@ -22,7 +22,11 @@ import {
   DEFAULT_REACTIVITY_SRC,
   DEFAULT_LIT_HTML_SRC,
 } from "./shared.js";
-import { compileServer, compileSiteServer } from "./targets/compile-server.js";
+import {
+  compileServer,
+  compileSiteServer,
+  compilePagesFunctions,
+} from "./targets/compile-server.js";
 import {
   compileElement,
   compileElementPage,
@@ -36,6 +40,7 @@ export {
   isDynamic,
   compileServer,
   compileSiteServer,
+  compilePagesFunctions,
   compileElement,
   compileElementPage,
   compileClient,

package/src/site/site-build.js

@@ -25,7 +25,7 @@ import { discoverPages, expandDynamicRoutes } from "./pages-discovery.js";
 import { resolveLayout } from "./layout-resolver.js";
 import { mergeHead, renderHead } from "./head-merger.js";
 import { injectContext } from "./context-injection.js";
-import { compile, compileServer, compileSiteServer } from "../compiler.js";
+import { compile, compileServer, compileSiteServer, compilePagesFunctions } from "../compiler.js";
 import { compileElement } from "../targets/compile-element.js";
 import {
   buildInitialScope,
@@ -177,7 +177,7 @@ export async function buildSite(projectRoot, options = {}) {
     for (const [, doc] of componentDefs) {
       const entries = collectServerEntries(doc);
       for (const entry of entries) {
-        const resolvedSrc = "./" + join("components", entry.src.replace(/^\.\//, ""));
+        const resolvedSrc = "./components/" + entry.src.replace(/^\.\//, "");
         siteServerEntries.push({ exportName: entry.exportName, src: resolvedSrc });
       }
     }
@@ -269,6 +269,7 @@ export async function buildSite(projectRoot, options = {}) {
 
   // ── 6c. Generate site-wide server worker ────────────────────────────────
   if (projectConfig.build.adapter) {
+    const adapter = projectConfig.build.adapter;
     log("Generating site-wide server worker...");
 
     const deduped = new Map();
@@ -276,18 +277,19 @@ export async function buildSite(projectRoot, options = {}) {
       if (!deduped.has(entry.exportName)) deduped.set(entry.exportName, entry);
     }
 
-    const workerSource = compileSiteServer([...deduped.values()], {
-      adapter: projectConfig.build.adapter,
-    });
+    if (adapter === "cloudflare-pages") {
+      const functions = compilePagesFunctions([...deduped.values()]);
 
-    if (workerSource) {
-      const workerPath = resolve(outDir, "worker.js");
-      writeFileSync(workerPath, workerSource, "utf8");
-      fileCount++;
-      log(`  Generated dist/worker.js (${deduped.size} server function(s))`);
+      for (const [filePath, source] of functions) {
+        const fullPath = resolve(outDir, filePath);
+        mkdirSync(resolve(fullPath, ".."), { recursive: true });
+        writeFileSync(fullPath, source, "utf8");
+        fileCount++;
+      }
 
-      // Copy server source files into dist/components/ so worker imports resolve
+      // Copy server source files so function imports resolve
       const distComponentsDir = resolve(outDir, "components");
+      mkdirSync(distComponentsDir, { recursive: true });
       for (const { src } of deduped.values()) {
         const srcFile = resolve(projectRoot, src.replace(/^\.\//, ""));
         const destFile = resolve(distComponentsDir, src.replace(/^\.\/components\//, ""));
@@ -295,6 +297,29 @@ export async function buildSite(projectRoot, options = {}) {
           copyFileSync(srcFile, destFile);
         }
       }
+
+      if (functions.size > 0) {
+        log(`  Generated ${functions.size} Pages function(s) in dist/functions/`);
+      }
+    } else {
+      const workerSource = compileSiteServer([...deduped.values()], { adapter });
+
+      if (workerSource) {
+        const workerPath = resolve(outDir, "worker.js");
+        writeFileSync(workerPath, workerSource, "utf8");
+        fileCount++;
+        log(`  Generated dist/worker.js (${deduped.size} server function(s))`);
+
+        // Copy server source files into dist/components/ so worker imports resolve
+        const distComponentsDir = resolve(outDir, "components");
+        for (const { src } of deduped.values()) {
+          const srcFile = resolve(projectRoot, src.replace(/^\.\//, ""));
+          const destFile = resolve(distComponentsDir, src.replace(/^\.\/components\//, ""));
+          if (existsSync(srcFile)) {
+            copyFileSync(srcFile, destFile);
+          }
+        }
+      }
     }
   }
 

package/src/site/site-loader.js

@@ -87,6 +87,15 @@ export function loadProjectConfig(projectRoot) {
   if (raw.imports) config.imports = raw.imports;
   if (raw.contentTypes) config.contentTypes = raw.contentTypes;
 
+  // Validate adapter
+  const VALID_ADAPTERS = ["cloudflare-workers", "cloudflare-pages", "node", "bun"];
+  if (config.build.adapter && !VALID_ADAPTERS.includes(config.build.adapter)) {
+    throw new Error(
+      `Unknown build adapter "${config.build.adapter}" in project.json. ` +
+        `Valid adapters: ${VALID_ADAPTERS.join(", ")}`,
+    );
+  }
+
   return {
     config,
     configPath,

package/src/targets/compile-server.js

@@ -69,7 +69,9 @@ export function compileSiteServer(entries, opts = {}) {
   const routes = entries.map(({ exportName }) => buildRoute(exportName, baseUrl)).join("\n");
 
   const adapterBlock =
-    adapter === "cloudflare" ? "\napp.all('*', (c) => c.env.ASSETS.fetch(c.req.raw))\n" : "\n";
+    adapter === "cloudflare-workers"
+      ? "\napp.all('*', (c) => c.env.ASSETS.fetch(c.req.raw))\n"
+      : "\n";
 
   return `// Generated by @jxsuite/compiler — do not edit manually
 import { Hono } from 'hono'
@@ -94,3 +96,42 @@ app.post('${baseUrl}/${exportName}', async (c) => {
   }
 })`;
 }
+
+/**
+ * Generate Cloudflare Pages Functions from pre-collected server entries. Returns a Map of relative
+ * file paths (under `functions/`) to source strings.
+ *
+ * @param {{ exportName: string; src: string }[]} entries - Resolved server entries
+ * @param {object} [opts]
+ * @param {string} [opts.baseUrl] - Base path prefix. Default is `'/_jx/server'`
+ * @returns {Map<string, string>} Map of output path → source (e.g.
+ *   `"functions/_jx/server/sendEmail.js"` → source)
+ */
+export function compilePagesFunctions(entries, opts = {}) {
+  const { baseUrl = "/_jx/server" } = opts;
+  const files = new Map();
+
+  for (const { exportName, src } of entries) {
+    const relativeSrc = src.startsWith("./") ? src : `./${src}`;
+    const funcPath = `functions${baseUrl}/${exportName}.js`;
+    const depth = funcPath.split("/").length - 1;
+    const importPath = "../".repeat(depth) + relativeSrc.replace(/^\.\//, "");
+
+    const source = `// Generated by @jxsuite/compiler — do not edit manually
+import { ${exportName} } from '${importPath}'
+
+export async function onRequestPost(context) {
+  const args = await context.request.json().catch(() => ({}))
+  try {
+    const result = await ${exportName}(args, context.env)
+    return Response.json(result)
+  } catch (e) {
+    return Response.json({ ok: false, error: e?.message ?? 'Server error' }, { status: 500 })
+  }
+}
+`;
+    files.set(funcPath, source);
+  }
+
+  return files;
+}