alinea/dist/cli/Generate.js

Headless git-based CMS

import {
  prettyBytes
} from "../chunks/chunk-HRTN3UQ6.js";
import "../chunks/chunk-NZLE2WMY.js";

// src/cli/Generate.ts
import * as fsp from "node:fs/promises";
import { createRequire } from "node:module";
import path from "node:path";
import { Config } from "alinea/core/Config";
import { exportSource } from "alinea/core/source/SourceExport";
import { genEffect } from "alinea/core/util/Async";
import { basename, join } from "alinea/core/util/Paths";
import { compileConfig } from "./generate/CompileConfig.js";
import { copyStaticFiles } from "./generate/CopyStaticFiles.js";
import { DevDB } from "./generate/DevDB.js";
import { fillCache } from "./generate/FillCache.js";
import { generateDashboard } from "./generate/GenerateDashboard.js";
import { dirname } from "./util/Dirname.js";
import { findConfigFile } from "./util/FindConfigFile.js";
import { reportError, reportFatal } from "./util/Report.js";
var __dirname = dirname(import.meta.url);
var require2 = createRequire(import.meta.url);
var alineaPackageDir = path.dirname(require2.resolve("alinea/package.json"));
async function generatePackage(context, cms) {
  const { config } = cms;
  if (!config.dashboardFile) return;
  const staticFile = config.dashboardFile ? join(config.publicDir, config.dashboardFile) : void 0;
  if (!staticFile) return;
  await generateDashboard(
    context,
    cms,
    config.handlerUrl ?? "/api/cms",
    staticFile
  );
  return basename(staticFile);
}
async function* generate(options) {
  const {
    cmd,
    wasmCache = false,
    cwd = process.cwd(),
    configFile,
    staticDir = path.join(__dirname, "static"),
    quiet = false,
    onAfterGenerate
  } = options;
  const now = performance.now();
  const configLocation = configFile ? path.join(path.resolve(cwd), configFile) : findConfigFile(cwd);
  if (!configLocation) throw new Error("No config file specified");
  const location = path.relative(process.cwd(), configLocation).replace(/\\/g, "/");
  const rootDir = path.resolve(cwd);
  const configDir = path.dirname(configLocation);
  const nodeModules = alineaPackageDir.includes("node_modules") ? path.join(alineaPackageDir, "..") : path.join(alineaPackageDir, "node_modules");
  const context = {
    cmd,
    wasmCache,
    rootDir,
    staticDir,
    quiet,
    configDir,
    configLocation,
    fix: options.fix || false,
    outDir: path.join(nodeModules, "@alinea/generated")
  };
  await copyStaticFiles(context);
  let indexing;
  const builder = compileConfig(context);
  const builds = genEffect(builder, () => indexing?.return());
  let afterGenerateCalled = false;
  async function writeStore(db) {
    const exported = await exportSource(db.source);
    const data = JSON.stringify(exported, null, 2);
    await fsp.writeFile(
      join(context.outDir, "source.js"),
      `export const source = ${data}`
    );
    return data.length;
  }
  for await (const cms of builds) {
    if (cmd === "build") {
      const handlerUrl = cms.config.handlerUrl;
      const baseUrl = Config.baseUrl(cms.config, "production");
      if (handlerUrl && !baseUrl) {
        reportFatal(
          "No baseUrl was set for the production build in Alinea config"
        );
        process.exit(1);
      }
    }
    const write = async (recordCount) => {
      let dbSize = 0;
      if (cmd === "build") {
        ;
        [, dbSize] = await Promise.all([
          generatePackage(context, cms),
          writeStore(db)
        ]);
      }
      let message = `${cmd} ${location} in `;
      const duration = performance.now() - now;
      if (duration > 1e3) message += `${(duration / 1e3).toFixed(2)}s`;
      else message += `${duration.toFixed(0)}ms`;
      if (dbSize > 0)
        message += ` (db ${prettyBytes(dbSize)}, ${recordCount} records)`;
      else message += ` (${recordCount} records)`;
      return message;
    };
    const db = new DevDB({
      config: cms.config,
      rootDir,
      dashboardUrl: await options.dashboardUrl
    });
    try {
      indexing = fillCache(db, context.fix);
    } catch (error) {
      reportError(error);
      if (cmd === "build") process.exit(1);
      continue;
    }
    for await (const db2 of indexing) {
      yield { cms, db: db2 };
      if (onAfterGenerate && !afterGenerateCalled) {
        const recordCount = await db2.count({});
        await write(recordCount ?? 0).then(
          (message) => {
            afterGenerateCalled = true;
            onAfterGenerate(message);
          },
          () => {
            reportFatal("Alinea failed to write dashboard files");
            if (cmd === "build") process.exit(1);
          }
        );
      }
    }
  }
}
export {
  generate
};