@beignet/cli 0.0.26 → 0.0.28

package/src/check.ts

@@ -0,0 +1,246 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createPainter } from "./ansi.js";
+import { detectPackageManager, spawnCommand } from "./db.js";
+import {
+  applyDoctorFixes,
+  formatDoctor,
+  type InspectFix,
+  inspectApp,
+} from "./inspect.js";
+import { formatLint, lintApp } from "./lint.js";
+
+/**
+ * One step of `beignet check`.
+ *
+ * `output` carries the failing step's formatted diagnostics or captured
+ * script output so the summary is actionable without a re-run.
+ */
+export type CheckStep = {
+  name: string;
+  command: string;
+  status: "passed" | "failed" | "skipped";
+  detail?: string;
+  output?: string;
+  durationMs: number;
+};
+
+export type CheckAppResult = {
+  schemaVersion: 1;
+  targetDir: string;
+  runner: string;
+  ok: boolean;
+  fixes: InspectFix[];
+  steps: CheckStep[];
+};
+
+export type CheckAppOptions = {
+  cwd?: string;
+  fix?: boolean;
+  color?: boolean;
+  /** Called after each step completes, for incremental progress output. */
+  onStep?: (step: CheckStep) => void;
+};
+
+const scriptStepNames = ["lint", "typecheck", "test"] as const;
+
+/**
+ * Run the whole app validation loop as one command: `beignet lint`,
+ * `beignet doctor --strict` (optionally with fixes), and the app's own
+ * `lint`, `typecheck`, and `test` package scripts through the detected
+ * package manager.
+ *
+ * Every step runs even when an earlier one fails, so a single run reports
+ * everything that needs fixing. Missing package scripts are reported as
+ * skipped, never as failures.
+ */
+export async function checkApp(
+  options: CheckAppOptions = {},
+): Promise<CheckAppResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const runner = await detectPackageManager(targetDir);
+  const steps: CheckStep[] = [];
+  const record = (step: CheckStep): void => {
+    steps.push(step);
+    options.onStep?.(step);
+  };
+
+  record(await lintStep(targetDir, options));
+  const { step: doctorStep, fixes } = await runDoctorStep(targetDir, options);
+  record(doctorStep);
+
+  const scripts = await readPackageScripts(targetDir);
+  for (const script of scriptStepNames) {
+    record(await scriptStep(targetDir, runner, script, scripts));
+  }
+
+  return {
+    schemaVersion: 1,
+    targetDir,
+    runner,
+    ok: steps.every((step) => step.status !== "failed"),
+    fixes,
+    steps,
+  };
+}
+
+/**
+ * Format a completed step as a single status line, with the failing step's
+ * output indented underneath.
+ */
+export function formatCheckStep(
+  step: CheckStep,
+  options: { color?: boolean } = {},
+): string {
+  const paint = createPainter(options.color);
+  const mark =
+    step.status === "passed"
+      ? paint("✓", "green")
+      : step.status === "failed"
+        ? paint("✗", "red")
+        : paint("-", "cyan");
+  const detail = step.detail ? ` (${step.detail})` : "";
+  const line = `${mark} ${step.name}${detail}`;
+  if (step.status !== "failed" || !step.output?.trim()) return line;
+
+  const indented = step.output
+    .trimEnd()
+    .split("\n")
+    .map((outputLine) => `  ${outputLine}`)
+    .join("\n");
+  return `${line}\n${indented}`;
+}
+
+/**
+ * Format the closing summary line, e.g. `3 passed, 1 failed, 1 skipped`.
+ */
+export function formatCheckSummary(
+  result: CheckAppResult,
+  options: { color?: boolean } = {},
+): string {
+  const paint = createPainter(options.color);
+  const counts = {
+    passed: result.steps.filter((step) => step.status === "passed").length,
+    failed: result.steps.filter((step) => step.status === "failed").length,
+    skipped: result.steps.filter((step) => step.status === "skipped").length,
+  };
+  const parts = [`${counts.passed} passed`];
+  if (counts.failed > 0) parts.push(paint(`${counts.failed} failed`, "red"));
+  if (counts.skipped > 0) parts.push(`${counts.skipped} skipped`);
+  return parts.join(", ");
+}
+
+/**
+ * Format a full result at once (JSON-free callers and tests).
+ */
+export function formatCheck(
+  result: CheckAppResult,
+  options: { color?: boolean } = {},
+): string {
+  const lines = result.steps.map((step) => formatCheckStep(step, options));
+  return `${lines.join("\n")}\n\n${formatCheckSummary(result, options)}`;
+}
+
+async function lintStep(
+  targetDir: string,
+  options: CheckAppOptions,
+): Promise<CheckStep> {
+  const startedAt = Date.now();
+  const result = await lintApp({ cwd: targetDir });
+  const failed = result.diagnostics.length > 0;
+
+  return {
+    name: "beignet lint",
+    command: "beignet lint",
+    status: failed ? "failed" : "passed",
+    ...(failed ? { output: formatLint(result, { color: options.color }) } : {}),
+    durationMs: Date.now() - startedAt,
+  };
+}
+
+async function runDoctorStep(
+  targetDir: string,
+  options: CheckAppOptions,
+): Promise<{ step: CheckStep; fixes: InspectFix[] }> {
+  const startedAt = Date.now();
+  const fixes = options.fix
+    ? await applyDoctorFixes({ cwd: targetDir, strict: true })
+    : [];
+  const result = await inspectApp({ cwd: targetDir, strict: true });
+  result.fixes = fixes;
+  const failed = result.diagnostics.some(
+    (diagnostic) =>
+      diagnostic.severity === "error" || diagnostic.severity === "warning",
+  );
+
+  return {
+    step: {
+      name: "beignet doctor --strict",
+      command: "beignet doctor --strict",
+      status: failed ? "failed" : "passed",
+      ...(fixes.length > 0
+        ? {
+            detail: `${fixes.length} ${fixes.length === 1 ? "fix" : "fixes"} applied`,
+          }
+        : {}),
+      ...(failed
+        ? { output: formatDoctor(result, { color: options.color }) }
+        : {}),
+      durationMs: Date.now() - startedAt,
+    },
+    fixes,
+  };
+}
+
+async function scriptStep(
+  targetDir: string,
+  runner: string,
+  script: (typeof scriptStepNames)[number],
+  scripts: Record<string, string>,
+): Promise<CheckStep> {
+  const command = `${runner} run ${script}`;
+  if (!scripts[script]) {
+    return {
+      name: script,
+      command,
+      status: "skipped",
+      detail: `no "${script}" script in package.json`,
+      durationMs: 0,
+    };
+  }
+
+  const startedAt = Date.now();
+  const result = await spawnCommand(runner, ["run", script], targetDir, {
+    captureOutput: true,
+  });
+  const failed = result.exitCode !== 0;
+
+  return {
+    name: script,
+    command,
+    status: failed ? "failed" : "passed",
+    detail: command,
+    ...(failed
+      ? { output: [result.stdout, result.stderr].filter(Boolean).join("\n") }
+      : {}),
+    durationMs: Date.now() - startedAt,
+  };
+}
+
+async function readPackageScripts(
+  targetDir: string,
+): Promise<Record<string, string>> {
+  let source: string;
+  try {
+    source = await readFile(path.join(targetDir, "package.json"), "utf8");
+  } catch {
+    throw new Error(
+      "Could not find package.json. Run beignet check from the app root.",
+    );
+  }
+
+  const parsed = JSON.parse(source) as {
+    scripts?: Record<string, string>;
+  };
+  return parsed.scripts ?? {};
+}

package/src/choices.ts

@@ -24,6 +24,19 @@ export type IntegrationName = "inngest" | "resend" | "upstash-rate-limit";
  * Databases supported by the starter's Drizzle persistence layer.
  */
 export type DatabaseName = "sqlite" | "postgres" | "mysql";
+/**
+ * Provider setup presets supported by `beignet providers add`.
+ */
+export type ProviderPresetName =
+  | "flags-openfeature"
+  | "mail-resend"
+  | "mail-smtp"
+  | "search-meilisearch"
+  | "sentry"
+  | "upstash-rate-limit"
+  | "redis-cache"
+  | "redis-locks"
+  | "s3-storage";
 
 /**
  * Supported scaffold template choices.
@@ -60,6 +73,21 @@ export const databaseChoices = [
   "mysql",
 ] as const satisfies readonly DatabaseName[];
 
+/**
+ * Supported provider setup preset choices.
+ */
+export const providerPresetChoices = [
+  "flags-openfeature",
+  "mail-resend",
+  "mail-smtp",
+  "search-meilisearch",
+  "sentry",
+  "upstash-rate-limit",
+  "redis-cache",
+  "redis-locks",
+  "s3-storage",
+] as const satisfies readonly ProviderPresetName[];
+
 /**
  * Local database name derived from the app name.
  *

package/src/db.ts

@@ -212,7 +212,7 @@ async function assertDatabaseCommandPreflight(
   }
 
   const standardEntrypoints: Partial<Record<DatabaseCommand, string>> = {
-    seed: "infra/db/seed.ts",
+    seed: "server/seed.ts",
     reset: "infra/db/reset.ts",
   };
   const standardEntrypoint = standardEntrypoints[command];
@@ -463,7 +463,7 @@ function missingDatabaseScriptMessage(
   }
 
   const entrypoint =
-    command === "seed" ? "infra/db/seed.ts" : "infra/db/reset.ts";
+    command === "seed" ? "server/seed.ts" : "infra/db/reset.ts";
   return `Missing package.json script "${script}". Standard Drizzle apps use "${script}": "bun ${entrypoint}" so beignet db ${command} can run the app-owned ${command} entrypoint.`;
 }
 
@@ -482,7 +482,7 @@ async function readPackageJson(cwd: string): Promise<PackageJson> {
   }
 }
 
-async function detectPackageManager(cwd: string): Promise<string> {
+export async function detectPackageManager(cwd: string): Promise<string> {
   if (await exists(path.join(cwd, "bun.lock"))) return "bun";
   if (await exists(path.join(cwd, "bun.lockb"))) return "bun";
   if (await exists(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
@@ -500,7 +500,7 @@ async function exists(filePath: string): Promise<boolean> {
   }
 }
 
-function spawnCommand(
+export function spawnCommand(
   command: string,
   args: readonly string[],
   cwd: string,