@beignet/cli 0.0.37 → 0.0.39

package/src/create-prompts.ts

@@ -7,26 +7,25 @@
  */
 
 import {
-  type CreateIntegrationName,
+  type CreateProviderName,
   type DatabaseName,
   databaseChoices,
-  type IntegrationName,
-  integrationChoices,
   type PackageManager,
+  type StarterProviderName,
+  starterProviderChoices,
 } from "./choices.js";
 
 /**
  * Selections shared by create flags and interactive prompt answers.
  *
- * `integrations` accepts the starter template integrations plus the full
- * `beignet providers add` preset catalog; the interactive prompt shows the
- * curated template list and points at the wider catalog.
+ * `providers` accepts the full `beignet provider add` preset catalog; the
+ * interactive prompt shows the providers rendered directly by the starter.
  */
 export type CreateSelections = {
   directory?: string;
   api?: boolean;
   db?: DatabaseName;
-  integrations?: readonly CreateIntegrationName[];
+  providers?: readonly CreateProviderName[];
   packageManager?: PackageManager;
 };
 
@@ -43,7 +42,7 @@ type CreatePromptTty = {
  * Decide whether `beignet create` should run the interactive prompt flow.
  *
  * Prompts run only on a full TTY, only when `--yes` is absent, and only when
- * no selection flag was passed. Any explicit api, database, integration, or
+ * no selection flag was passed. Any explicit api, database, provider, or
  * package manager selection means the invocation is scripted, so the
  * non-interactive path stays byte-identical for agents and CI.
  */
@@ -57,16 +56,16 @@ export function shouldPromptInteractively(
   const selectionFlagPassed =
     flags.api !== undefined ||
     flags.db !== undefined ||
-    (flags.integrations?.length ?? 0) > 0 ||
+    (flags.providers?.length ?? 0) > 0 ||
     flags.packageManager !== undefined;
 
   return !selectionFlagPassed;
 }
 
-const integrationHints: Record<IntegrationName, string> = {
-  inngest: "Inngest-backed background jobs",
-  resend: "Resend-backed mail provider",
-  "upstash-rate-limit": "Upstash-backed rate limiting",
+const providerHints: Record<StarterProviderName, string> = {
+  "jobs-inngest": "Inngest-backed background jobs",
+  "mail-resend": "Resend-backed mail provider",
+  "rate-limit-upstash": "Upstash-backed rate limiting",
 };
 
 const databaseHints: Record<DatabaseName, string> = {
@@ -118,17 +117,17 @@ export async function promptCreateSelections(
   });
   if (prompts.isCancel(db)) return undefined;
 
-  const integrations = await prompts.multiselect<IntegrationName>({
+  const providers = await prompts.multiselect<StarterProviderName>({
     message:
-      "Add provider integrations? (press enter to skip; the full preset catalog is available via --integrations or beignet providers add)",
-    options: integrationChoices.map((integration) => ({
-      value: integration,
-      label: integration,
-      hint: integrationHints[integration],
+      "Add providers? (press enter to skip; the full catalog is available via --providers or beignet provider add)",
+    options: starterProviderChoices.map((provider) => ({
+      value: provider,
+      label: provider,
+      hint: providerHints[provider],
     })),
     required: false,
   });
-  if (prompts.isCancel(integrations)) return undefined;
+  if (prompts.isCancel(providers)) return undefined;
 
   prompts.outro(`Creating ${directory}`);
 
@@ -136,7 +135,7 @@ export async function promptCreateSelections(
     directory,
     api,
     db,
-    integrations,
+    providers,
     packageManager: initial.packageManager,
   };
 }

package/src/create.ts

@@ -4,9 +4,10 @@ import {
   type DatabaseName,
   databaseChoices,
   getTemplateFiles,
-  type IntegrationName,
-  integrationChoices,
   type PackageManager,
+  type StarterProviderName,
+  starterProviderChoices,
+  type TemplateFile,
   type TemplateName,
 } from "./templates/index.js";
 import { getCliVersion } from "./version.js";
@@ -23,7 +24,7 @@ export type CreateOptions = {
    */
   api?: boolean;
   packageManager?: PackageManager;
-  integrations?: IntegrationName[];
+  providers?: StarterProviderName[];
   /**
    * Database backing the starter's Drizzle persistence layer.
    * Defaults to "sqlite".
@@ -47,19 +48,46 @@ export type CreateResult = {
   database: DatabaseName;
 };
 
+export type CreateProjectPlan = {
+  result: CreateResult;
+  files: TemplateFile[];
+};
+
 /**
  * Create a Beignet app from the starter template.
  */
 export async function createProject(
   options: CreateOptions,
 ): Promise<CreateResult> {
+  const plan = await planCreateProject(options);
+
+  if (!plan.result.dryRun) {
+    await mkdir(plan.result.targetDir, { recursive: true });
+
+    for (const file of plan.files) {
+      const destination = path.join(plan.result.targetDir, file.path);
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, file.content);
+    }
+  }
+
+  return plan.result;
+}
+
+/**
+ * Render a scaffold without writing it so create-time provider presets can
+ * compose against the exact same file contents as a real create.
+ */
+export async function planCreateProject(
+  options: CreateOptions,
+): Promise<CreateProjectPlan> {
   const cwd = options.cwd ?? process.cwd();
   const name = normalizeProjectName(options.name);
   const targetDir = path.resolve(cwd, options.name);
   const packageManager = options.packageManager ?? "bun";
   const template = options.template ?? "next";
   const api = Boolean(options.api);
-  const integrations = resolveIntegrations(options.integrations ?? []);
+  const providers = resolveStarterProviders(options.providers ?? []);
   const database = options.db ?? "sqlite";
 
   if (template !== "next") {
@@ -83,58 +111,48 @@ export async function createProject(
     packageManager,
     beignetVersion: options.beignetVersion ?? getDefaultBeignetVersion(),
     api,
-    integrations,
+    providers,
     database,
   });
 
-  if (!dryRun) {
-    await mkdir(targetDir, { recursive: true });
-
-    for (const file of files) {
-      const destination = path.join(targetDir, file.path);
-      await mkdir(path.dirname(destination), { recursive: true });
-      await writeFile(destination, file.content);
-    }
-  }
-
   return {
-    schemaVersion: 1,
-    name,
-    targetDir,
-    dryRun,
-    files: files.map((file) => file.path),
-    packageManager,
-    database,
+    result: {
+      schemaVersion: 1,
+      name,
+      targetDir,
+      dryRun,
+      files: files.map((file) => file.path),
+      packageManager,
+      database,
+    },
+    files,
   };
 }
 
 /**
- * Providers that ship in every starter. They used to be `--integrations`
- * choices, so passing them gets a pointed error instead of a generic one.
+ * Providers that ship in every starter are not selectable additions.
  */
 const baseProviderNames = new Set(["better-auth", "drizzle-sqlite", "pino"]);
 
-function resolveIntegrations(
-  explicitIntegrations: IntegrationName[],
-): IntegrationName[] {
-  for (const integration of explicitIntegrations) {
-    const integrationName: string = integration;
-    if (baseProviderNames.has(integrationName)) {
+function resolveStarterProviders(
+  explicitProviders: StarterProviderName[],
+): StarterProviderName[] {
+  for (const provider of explicitProviders) {
+    const providerName: string = provider;
+    if (baseProviderNames.has(providerName)) {
       const databaseHint =
-        integrationName === "drizzle-sqlite"
+        providerName === "drizzle-sqlite"
           ? " Choose the starter database with --db sqlite|postgres|mysql instead."
           : "";
       throw new Error(
-        `${integration} is part of every Beignet starter and no longer an --integrations choice.${databaseHint}`,
+        `${provider} is part of every Beignet starter and is not a --providers choice.${databaseHint}`,
       );
     }
   }
 
-  const integrations = new Set<IntegrationName>(explicitIntegrations);
+  const providers = new Set<StarterProviderName>(explicitProviders);
 
-  return integrationChoices.filter((integration) =>
-    integrations.has(integration),
-  );
+  return starterProviderChoices.filter((provider) => providers.has(provider));
 }
 
 function getDefaultBeignetVersion(): string {