alinea/dist/cli/Serve.js

Headless git-based CMS

import {
  package_default
} from "../chunks/chunk-NWJMNYVI.js";
import "../chunks/chunk-NZLE2WMY.js";

// src/cli/Serve.ts
import path from "node:path";
import { createHandler } from "alinea/backend/Handler";
import { createRemote } from "alinea/backend/api/CreateBackend";
import { gitUser } from "alinea/backend/util/ExecGit";
import { CloudRemote } from "alinea/cloud/CloudRemote";
import { createId } from "alinea/core/Id";
import { genEffect } from "alinea/core/util/Async";
import { generate } from "./Generate.js";
import { buildOptions } from "./build/BuildOptions.js";
import { createLocalServer } from "./serve/CreateLocalServer.js";
import { GitHistory } from "./serve/GitHistory.js";
import { LiveReload } from "./serve/LiveReload.js";
import { LocalAuth } from "./serve/LocalAuth.js";
import { MemoryDrafts } from "./serve/MemoryDrafts.js";
import { startServer } from "./serve/StartServer.js";
import { dirname } from "./util/Dirname.js";
import { findConfigFile } from "./util/FindConfigFile.js";
import { bold, cyan, gray, reportFatal } from "./util/Report.js";
var __dirname = dirname(import.meta.url);
async function serve(options) {
  const {
    cwd = process.cwd(),
    base,
    configFile,
    staticDir = path.join(__dirname, "static"),
    alineaDev = false,
    production = false,
    cmd
  } = options;
  const configLocation = configFile ? path.join(path.resolve(cwd), configFile) : findConfigFile(cwd);
  if (!configLocation) {
    reportFatal(`No Alinea config file found @ ${cwd}`);
    process.exit(1);
  }
  const preferredPort = options.port ? Number(options.port) : 4500;
  const server = startServer(preferredPort, 0, cmd === "build");
  const dashboardUrl = server.then((server2) => `http://localhost:${server2.port}`);
  const rootDir = path.resolve(cwd);
  const context = {
    cmd,
    configLocation,
    rootDir,
    base,
    staticDir,
    alineaDev,
    buildOptions: {
      ...buildOptions,
      ...options.buildOptions,
      plugins: (buildOptions.plugins || []).concat(
        options.buildOptions?.plugins || []
      )
    },
    production,
    liveReload: new LiveReload(),
    buildId: createId()
  };
  const drafts = new MemoryDrafts();
  let currentCMS;
  let serveController = new AbortController();
  let localServer;
  const fileEmitter = generate({
    ...options,
    dashboardUrl,
    watch: cmd === "dev",
    onAfterGenerate(msg) {
      dashboardUrl.then((url) => {
        const version = gray(package_default.version);
        const header = `  ${cyan(bold("\u0251 alinea"))} ${version}
`;
        const connector = gray(cmd === "dev" ? "\u251C" : "\u2570");
        const details = `  ${connector} ${gray(msg)}
`;
        const footer = cmd === "dev" ? `  ${gray("\u2570")} Local CMS:    ${url}

` : "\n";
        process.stdout.write(header + details + footer);
        options.onAfterGenerate?.({
          ALINEA_DEV_SERVER: url
        });
      });
    }
  });
  const generateFiles = genEffect(fileEmitter, () => {
    serveController.abort();
    serveController = new AbortController();
  });
  const user = gitUser(rootDir);
  for await (const { cms, db } of generateFiles) {
    if (currentCMS === cms) {
      context.liveReload.reload("refetch");
    } else {
      let backend2 = function(context2) {
        if (process.env.ALINEA_CLOUD_URL)
          return new CloudRemote(context2, cms.config);
        const auth = new LocalAuth(context2, user);
        return createRemote(auth, db, drafts, history);
      };
      var backend = backend2;
      const history = new GitHistory(cms.config, rootDir);
      const handleApi = createHandler({
        cms,
        remote: backend2,
        db
      });
      if (localServer) localServer.close();
      localServer = createLocalServer(context, cms, handleApi, await user);
      currentCMS = cms;
    }
    const { serve: serve2 } = await server;
    for await (const { request, respondWith } of serve2(serveController)) {
      localServer.handle(request).then(respondWith);
    }
  }
  const { close } = await server;
  close();
}
export {
  serve
};