@stelstone/server 0.26.0

package/src/server.mjs

@@ -0,0 +1,325 @@
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveAdminUiDir, resolveAdminUiSourceDir, resolveAdminUiVersion } from "./admin-ui-path.mjs";
+import { defaultPublicConfig } from "./default-public-config.mjs";
+import { createRequestHandler } from "./core/handler.mjs";
+import { toNodeMiddleware } from "./core/node-adapter.mjs";
+import { createStaticHandler, fileResponse } from "./core/static-files.mjs";
+import { assertValidConfig, describeConfig } from "./core/config-schema.mjs";
+import {
+  githubContentOptions,
+  fsContentOptions,
+  githubTemplatesOptions,
+  authOptions,
+  netlifyBuildOptions,
+  cdnMediaOptions,
+  mailOptions,
+} from "./core/adapter-options.mjs";
+import {
+  createFsJsonContent,
+  createGitHubContent,
+  createLocalAssetsMedia,
+  createCdnProxyMedia,
+  createBasicAuth,
+  createGitHubOAuth,
+  createCloudflareAccess,
+  createNetlifyBuild,
+  createFsTemplates,
+  createGitHubTemplates,
+  createResendMail,
+} from "./adapters/index.mjs";
+import { createMemoryRateLimiter } from "./core/forms.mjs";
+
+/**
+ * Build the CMS request handler for the Node runtime.
+ *
+ * Request policy lives in `core/handler.mjs`, shared with the Worker runtime;
+ * this module only wires adapters and adds the Node-only pieces (serving local
+ * asset files from disk).
+ *
+ * @param {Object} opts
+ * @param {Object} opts.config               cms.config object
+ * @param {string} opts.rootDir              absolute path to consumer project root
+ * @param {() => Object} [opts.publicConfig] returns sanitized config for the browser
+ * @param {string} [opts.realm]              retained for API compatibility
+ * @returns {{ handle: (req: Request) => Promise<Response|null>,
+ *             middleware: Function, adapters: Object }}
+ */
+export function createCmsServer({ config, rootDir, publicConfig: publicConfigFn, realm = "CMS Admin" }) {
+  const secrets = (name) => (name ? process.env[name] : undefined);
+
+  // Refuse to start on a broken config, and report every problem at once
+  // rather than the first one encountered.
+  assertValidConfig(config, { runtime: "node", getSecret: secrets });
+
+  const useGitHub = config.content?.provider === "github";
+
+  const content = useGitHub
+    ? createGitHubContent(githubContentOptions(config, secrets))
+    : createFsJsonContent(fsContentOptions(config, secrets, rootDir));
+
+  const localMedia = createLocalAssetsMedia({
+    rootDir,
+    assetsDir: config.content.assetsDir,
+  });
+
+  const { provider: authProvider, options: authOpts } = authOptions(config, secrets);
+  const auth =
+    authProvider === "github-oauth"
+      ? createGitHubOAuth({ ...authOpts, realm })
+      : authProvider === "cloudflare-access"
+        ? createCloudflareAccess(authOpts)
+        : createBasicAuth({ ...authOpts, realm });
+
+  if (!auth.configured) {
+    console.warn("WARNING: no CMS credentials configured — running without authentication");
+  }
+
+  // No media config → no CDN adapter; the media routes answer 404 instead
+  // of every /api request dying while the adapter bag is built.
+  const cdnMedia = config.media ? createCdnProxyMedia(cdnMediaOptions(config, auth)) : undefined;
+  const build = createNetlifyBuild(netlifyBuildOptions(config, secrets));
+
+  const templates = useGitHub
+    ? createGitHubTemplates(githubTemplatesOptions(config, secrets))
+    : createFsTemplates({ rootDir });
+
+  const adapters = {
+    content,
+    templates,
+    localMedia,
+    cdnMedia,
+    auth,
+    build,
+    // Forms: Resend delivery + a per-process rate limiter. The Worker builds
+    // the same pair with a KV-backed limiter.
+    mail: config.mail ? createResendMail(mailOptions(config, secrets)) : undefined,
+    formLimiter: createMemoryRateLimiter(),
+    publicConfig: () => (publicConfigFn ?? defaultPublicConfig)(config),
+  };
+
+  const handleApi = createRequestHandler({
+    config,
+    adapters,
+    runtime: "node",
+    // Read from the package this server would actually serve, not baked in.
+    adminUiVersion: resolveAdminUiVersion(),
+  });
+
+  // Local asset files are static and public, exactly as before.
+  const assetFiles = createStaticHandler({
+    root: path.join(rootDir, config.content.assetsDir || "src/assets"),
+    mount: localMedia.urlPrefix,
+  });
+
+  async function handle(request) {
+    const apiResponse = await handleApi(request);
+    if (apiResponse) return apiResponse;
+    return assetFiles(request);
+  }
+
+  return { handle, middleware: toNodeMiddleware(handle), adapters };
+}
+
+/**
+ * Start a background scheduler that auto-publishes entries whose
+ * `meta.publishAt` timestamp has passed. Runs every 60 seconds.
+ * Returns a stop function.
+ */
+export function startScheduler(content, intervalMs = 60_000) {
+  async function run() {
+    try {
+      const due = await content.listScheduled();
+      if (!due.length) return;
+      const items = due.map(({ collection, file, data }) => {
+        delete data.meta.publishAt;
+        data.meta.draft = false;
+        return { collection, file, data };
+      });
+      await content.writeBatch(items, "[scheduler] Auto-publish");
+      console.log(`[scheduler] Auto-published ${items.length} item(s)`);
+      // fs adapter commits at publish time — scoped to the scheduled entries
+      // only, so an editor's unfinished draft never gets swept into the
+      // scheduler's commit. (github adapter ignores both args, its writeBatch
+      // already committed with the message.)
+      const result = await content.publish("[scheduler] Auto-publish", {
+        entries: items.map(({ collection, file }) => ({ collection, file })),
+      });
+      console.log("[scheduler] " + result.message);
+    } catch (err) {
+      console.error("[scheduler] Error:", err.message);
+    }
+  }
+  const timer = setInterval(run, intervalMs);
+  return () => clearInterval(timer);
+}
+
+/** Serve the prebuilt admin SPA, plus the optional per-site preview stylesheet. */
+function createAdminUiHandler({ dir, previewThemeCss }) {
+  const files = createStaticHandler({ root: dir, mount: "/admin", spaFallback: true });
+  return function serveAdminUi(request) {
+    const { pathname } = new URL(request.url);
+    // Answer before the static handler so the <link> never 404s.
+    if (pathname === "/admin/preview-theme.css") {
+      if (previewThemeCss && fs.existsSync(previewThemeCss)) {
+        return fileResponse(path.resolve(previewThemeCss));
+      }
+      return new Response("/* no preview-theme.css configured */", {
+        headers: { "Content-Type": "text/css" },
+      });
+    }
+    return files(request);
+  };
+}
+
+/** Mount connect-style middleware under a URL prefix, stripping it like connect does. */
+function mountPrefix(prefix, middleware) {
+  return (req, res, next) => {
+    const url = req.url || "/";
+    if (url !== prefix && !url.startsWith(`${prefix}/`) && !url.startsWith(`${prefix}?`)) {
+      return next();
+    }
+    const originalUrl = url;
+    req.url = url.slice(prefix.length) || "/";
+    middleware(req, res, (err) => {
+      req.url = originalUrl;
+      next(err);
+    });
+  };
+}
+
+/**
+ * Decide which admin UI to mount.
+ *
+ * Dev prefers the admin-ui *source* (Vite + HMR), but that only exists in a
+ * monorepo/linked checkout — the published tarball ships `dist` alone. So a
+ * missing source is not an error: fall back to the built bundle. Consumers
+ * that skip this fallback end up with `/admin` unmounted and a confusing 404
+ * while the API works fine.
+ *
+ * Returns an options object for `resolveAdminUi`, or null when neither the
+ * source nor a built dist is present.
+ */
+export function resolveAdminUiOptions({ dev = false, previewThemeCss = null, onWarn = console.warn } = {}) {
+  if (dev) {
+    const root = resolveAdminUiSourceDir();
+    if (root) return { mode: "vite-dev", root, base: "/admin/", previewThemeCss };
+    // Not worth a warning on its own: serving the built bundle is the normal
+    // case for an installed package, it just means no HMR for the admin UI.
+  }
+  const dir = resolveAdminUiDir();
+  if (!dir) {
+    onWarn("admin-ui not found — run `npm run build:admin-ui`, or pass the adminUi option explicitly.");
+    return null;
+  }
+  return { mode: "static", dir, previewThemeCss };
+}
+
+/**
+ * Resolve the admin UI into something mountable. Three modes:
+ *   { mode: "static", dir }                       serve a prebuilt SPA bundle
+ *   { mode: "vite-dev", root, base="/admin/" }    use Vite middleware (HMR)
+ *   { mode: "auto", distDir, sourceDir }          vite-dev when NODE_ENV !== "production"
+ *
+ * Returns `{ fetchHandler }` for the static mode and `{ nodeMiddleware }` for
+ * Vite, since Vite's dev server is connect-based and not a Fetch handler.
+ */
+export async function resolveAdminUi(adminUi) {
+  if (!adminUi) return {};
+
+  const resolved =
+    adminUi.mode === "auto"
+      ? process.env.NODE_ENV === "production"
+        ? { mode: "static", dir: adminUi.distDir, previewThemeCss: adminUi.previewThemeCss }
+        : {
+            mode: "vite-dev",
+            root: adminUi.sourceDir,
+            base: adminUi.base || "/admin/",
+            previewThemeCss: adminUi.previewThemeCss,
+          }
+      : adminUi;
+
+  if (resolved.mode === "static") {
+    if (!fs.existsSync(path.join(resolved.dir, "index.html"))) {
+      throw new Error(
+        `admin-ui not built at ${resolved.dir}. Run the admin-ui build before starting the server in production.`,
+      );
+    }
+    return { fetchHandler: createAdminUiHandler(resolved) };
+  }
+
+  if (resolved.mode === "vite-dev") {
+    const { createServer: createViteServer } = await import("vite");
+    const vite = await createViteServer({
+      root: resolved.root,
+      base: resolved.base || "/admin/",
+      server: { middlewareMode: true },
+      appType: "spa",
+    });
+    console.log("Admin UI: Vite dev middleware (HMR enabled)");
+    return {
+      nodeMiddleware: mountPrefix("/admin", vite.middlewares),
+      previewThemeCss: resolved.previewThemeCss,
+    };
+  }
+
+  throw new Error(`Unknown adminUi mode: ${resolved.mode}`);
+}
+
+/** Run a connect-style middleware chain, ending in 404. */
+function runChain(chain, req, res) {
+  let i = 0;
+  const next = (err) => {
+    if (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      return res.end(JSON.stringify({ error: err.message }));
+    }
+    const middleware = chain[i++];
+    if (!middleware) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      return res.end("Not found");
+    }
+    middleware(req, res, next);
+  };
+  next();
+}
+
+/**
+ * Convenience: build the handler, mount the admin UI, listen on a port.
+ * Returns { server, handle, adapters, stopScheduler }.
+ */
+export async function startCmsServer(opts) {
+  const { handle, adapters } = createCmsServer(opts);
+
+  const previewThemeCss = opts.config?.previewThemeCss
+    ? path.resolve(opts.rootDir || process.cwd(), opts.config.previewThemeCss)
+    : null;
+
+  const adminUiOpts =
+    opts.adminUi ?? resolveAdminUiOptions({ dev: opts.dev, previewThemeCss });
+
+  const adminUi = await resolveAdminUi(adminUiOpts);
+
+  // API and local assets first, then the admin SPA, then Vite (dev only).
+  const chain = [
+    toNodeMiddleware(async (request) => (await handle(request)) ?? adminUi.fetchHandler?.(request) ?? null),
+    adminUi.nodeMiddleware,
+  ].filter(Boolean);
+
+  const stopScheduler = startScheduler(adapters.content);
+  const port = opts.port || process.env.ADMIN_PORT || 4000;
+
+  return await new Promise((resolve) => {
+    const server = http.createServer((req, res) => runChain(chain, req, res));
+    server.listen(port, () => {
+      // Print what actually resolved, so a misconfiguration shows up in the
+      // first lines of the log instead of as odd behaviour later.
+      for (const line of describeConfig(opts.config, { adapters, runtime: "node" })) {
+        console.log(line);
+      }
+      console.log(`Admin server running at http://localhost:${port}/admin`);
+      resolve({ server, handle, adapters, stopScheduler });
+    });
+  });
+}

package/src/version.mjs

@@ -0,0 +1,8 @@
+/**
+ * Generated by scripts/sync-versions.mjs — do not edit.
+ *
+ * A constant rather than a package.json read: the Worker bundle has no
+ * require() and no import.meta.url, so reading the manifest at runtime yields
+ * "unknown" there.
+ */
+export const SERVER_VERSION = "0.26.0";