@beignet/cli 0.0.31 → 0.0.32

package/src/check.ts

@@ -38,6 +38,8 @@ export type CheckAppOptions = {
   cwd?: string;
   fix?: boolean;
   color?: boolean;
+  /** Append a `beignet preflight` step after the doctor step. */
+  preflight?: boolean;
   /** Called after each step completes, for incremental progress output. */
   onStep?: (step: CheckStep) => void;
 };
@@ -69,6 +71,10 @@ export async function checkApp(
   const { step: doctorStep, fixes } = await runDoctorStep(targetDir, options);
   record(doctorStep);
 
+  if (options.preflight) {
+    record(await preflightStep(targetDir));
+  }
+
   const scripts = await readPackageScripts(targetDir);
   for (const script of scriptStepNames) {
     record(await scriptStep(targetDir, runner, script, scripts));
@@ -244,3 +250,20 @@ async function readPackageScripts(
   };
   return parsed.scripts ?? {};
 }
+
+async function preflightStep(targetDir: string): Promise<CheckStep> {
+  const startedAt = Date.now();
+  const { formatPreflight, runPreflight } = await import("./preflight.js");
+  const result = await runPreflight({ cwd: targetDir });
+  const failed = result.findings.some(
+    (finding) => finding.severity === "error",
+  );
+
+  return {
+    name: "beignet preflight",
+    command: "beignet preflight",
+    status: failed ? "failed" : "passed",
+    ...(failed ? { output: formatPreflight(result, targetDir) } : {}),
+    durationMs: Date.now() - startedAt,
+  };
+}

package/src/choices.ts

@@ -29,8 +29,11 @@ export type DatabaseName = "sqlite" | "postgres" | "mysql";
  */
 export type ProviderPresetName =
   | "flags-openfeature"
+  | "jobs-bullmq"
+  | "jobs-inngest"
   | "mail-resend"
   | "mail-smtp"
+  | "payments-stripe"
   | "search-meilisearch"
   | "sentry"
   | "upstash-rate-limit"
@@ -79,8 +82,11 @@ export const databaseChoices = [
  */
 export const providerPresetChoices = [
   "flags-openfeature",
+  "jobs-bullmq",
+  "jobs-inngest",
   "mail-resend",
   "mail-smtp",
+  "payments-stripe",
   "search-meilisearch",
   "sentry",
   "upstash-rate-limit",
@@ -90,6 +96,81 @@ export const providerPresetChoices = [
   "vercel-blob-storage",
 ] as const satisfies readonly ProviderPresetName[];
 
+/**
+ * Values accepted by `beignet create --integrations`: the starter template
+ * integrations plus the full `beignet providers add` preset catalog.
+ */
+export type CreateIntegrationName = IntegrationName | ProviderPresetName;
+
+/**
+ * Supported `beignet create --integrations` choices. Template integrations
+ * come first; the rest of the provider preset catalog follows.
+ */
+export const createIntegrationChoices = [
+  "inngest",
+  "resend",
+  "upstash-rate-limit",
+  "flags-openfeature",
+  "jobs-bullmq",
+  "jobs-inngest",
+  "mail-resend",
+  "mail-smtp",
+  "payments-stripe",
+  "redis-cache",
+  "redis-locks",
+  "s3-storage",
+  "search-meilisearch",
+  "sentry",
+  "vercel-blob-storage",
+] as const satisfies readonly CreateIntegrationName[];
+
+/**
+ * Provider presets whose create-time wiring already ships as a starter
+ * template integration. Selecting the preset name at create time scaffolds
+ * the equivalent template integration, so preset and integration stay
+ * consistent and `beignet providers add` remains a no-op afterwards.
+ */
+const presetTemplateIntegrationAliases: Partial<
+  Record<ProviderPresetName, IntegrationName>
+> = {
+  "jobs-inngest": "inngest",
+  "mail-resend": "resend",
+  "upstash-rate-limit": "upstash-rate-limit",
+};
+
+/**
+ * Split `--integrations` selections into starter template integrations and
+ * provider presets applied with the `beignet providers add` machinery after
+ * the scaffold is written. Preset names with a template equivalent are
+ * normalized to the template integration; duplicates collapse.
+ */
+export function splitCreateIntegrations(
+  values: readonly CreateIntegrationName[],
+): {
+  integrations: IntegrationName[];
+  presets: ProviderPresetName[];
+} {
+  const integrations = new Set<IntegrationName>();
+  const presets = new Set<ProviderPresetName>();
+
+  for (const value of values) {
+    if ((integrationChoices as readonly string[]).includes(value)) {
+      integrations.add(value as IntegrationName);
+      continue;
+    }
+
+    const preset = value as ProviderPresetName;
+    const alias = presetTemplateIntegrationAliases[preset];
+    if (alias) {
+      integrations.add(alias);
+    } else {
+      presets.add(preset);
+    }
+  }
+
+  return { integrations: [...integrations], presets: [...presets] };
+}
+
 /**
  * Local database name derived from the app name.
  *

package/src/config.ts

@@ -32,6 +32,7 @@ export type BeignetPaths = {
   schedulesBuilder: string;
   notificationsBuilder: string;
   tasksBuilder: string;
+  uploadsBuilder: string;
   tests: string;
 };
 
@@ -100,6 +101,7 @@ export const defaultBeignetConfig: ResolvedBeignetConfig = {
     schedulesBuilder: "lib/schedules.ts",
     notificationsBuilder: "lib/notifications.ts",
     tasksBuilder: "lib/tasks.ts",
+    uploadsBuilder: "lib/uploads.ts",
     tests: "tests",
   },
   database: {

package/src/create-prompts.ts

@@ -7,6 +7,7 @@
  */
 
 import {
+  type CreateIntegrationName,
   type DatabaseName,
   databaseChoices,
   type IntegrationName,
@@ -16,12 +17,16 @@ import {
 
 /**
  * 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.
  */
 export type CreateSelections = {
   directory?: string;
   api?: boolean;
   db?: DatabaseName;
-  integrations?: readonly IntegrationName[];
+  integrations?: readonly CreateIntegrationName[];
   packageManager?: PackageManager;
 };
 
@@ -114,7 +119,8 @@ export async function promptCreateSelections(
   if (prompts.isCancel(db)) return undefined;
 
   const integrations = await prompts.multiselect<IntegrationName>({
-    message: "Add provider integrations? (press enter to skip)",
+    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,

package/src/db.ts

@@ -36,7 +36,7 @@ export type RunDatabaseCommandResult = {
 export type DatabaseSchemaDialect = "sqlite" | "postgres" | "mysql";
 export type DatabaseSchemaTable = "audit" | "idempotency" | "outbox";
 
-export type GenerateDatabaseSchemaOptions = {
+export type SyncDatabaseSchemaOptions = {
   cwd?: string;
   dialect?: DatabaseSchemaDialect;
   tables?: readonly DatabaseSchemaTable[];
@@ -44,9 +44,9 @@ export type GenerateDatabaseSchemaOptions = {
   dryRun?: boolean;
 };
 
-export type GenerateDatabaseSchemaResult = {
+export type SyncDatabaseSchemaResult = {
   schemaVersion: 1;
-  command: "schema:generate";
+  command: "schema:sync";
   cwd: string;
   dialect: DatabaseSchemaDialect;
   tables: DatabaseSchemaTable[];
@@ -132,15 +132,15 @@ export async function runDatabaseCommand(
 }
 
 /**
- * Generate the app-owned Drizzle schema entrypoint for Beignet provider tables.
+ * Sync the app-owned Drizzle schema entrypoint for Beignet provider tables.
  *
  * This only writes schema source. The app still owns SQL migration generation
  * through `beignet db generate` and migration application through
  * `beignet db migrate`.
  */
-export async function generateDatabaseSchema(
-  options: GenerateDatabaseSchemaOptions = {},
-): Promise<GenerateDatabaseSchemaResult> {
+export async function syncDatabaseSchema(
+  options: SyncDatabaseSchemaOptions = {},
+): Promise<SyncDatabaseSchemaResult> {
   const cwd = path.resolve(options.cwd ?? process.cwd());
   const dialect = await resolveDatabaseSchemaDialect(cwd, options.dialect);
   const tables = uniqueSchemaTables(options.tables ?? allDatabaseSchemaTables);
@@ -159,9 +159,9 @@ export async function generateDatabaseSchema(
     throw new Error("Schema output must not be the schema index file.");
   }
 
-  const result: GenerateDatabaseSchemaResult = {
+  const result: SyncDatabaseSchemaResult = {
     schemaVersion: 1,
-    command: "schema:generate",
+    command: "schema:sync",
     cwd,
     dialect,
     tables,
@@ -345,7 +345,7 @@ function renderDatabaseSchema(
   const tableNames = selectedTables.map((table) => table.tableName);
   const exportNames = selectedTables.map((table) => table.exportName).sort();
 
-  return `// Generated by beignet db schema generate.
+  return `// Managed by beignet db schema sync.
 // Required tables: ${tableNames.join(", ")}.
 // Re-run this command after upgrading @beignet/provider-db-drizzle.
 
@@ -437,7 +437,7 @@ async function readTextIfExists(file: string): Promise<string | undefined> {
 }
 
 function recordFileStatus(
-  result: GenerateDatabaseSchemaResult,
+  result: SyncDatabaseSchemaResult,
   file: string,
   status: FileWriteStatus,
 ): void {

package/src/index.ts

@@ -15,12 +15,13 @@ import {
 } from "@stricli/core";
 import {
   type CompletionShell,
+  type CreateIntegrationName,
   completionShellChoices,
+  createIntegrationChoices,
   type DatabaseName,
   databaseChoices,
   databaseStartCommand,
   type IntegrationName,
-  integrationChoices,
   type MakeFeatureAddon,
   type MakeFeatureRecipe,
   makeFeatureAddonChoices,
@@ -29,6 +30,7 @@ import {
   type ProviderPresetName,
   packageManagerChoices,
   providerPresetChoices,
+  splitCreateIntegrations,
   type TemplateName,
   templateChoices,
 } from "./choices.js";
@@ -54,7 +56,7 @@ type CreateFlags = {
   api?: boolean;
   db?: DatabaseName;
   packageManager?: PackageManager;
-  integrations?: readonly IntegrationName[];
+  integrations?: readonly CreateIntegrationName[];
   yes?: boolean;
   force?: boolean;
   dryRun?: boolean;
@@ -108,6 +110,16 @@ type LintFlags = {
 type CheckFlags = {
   json?: boolean;
   fix?: boolean;
+  preflight?: boolean;
+  cwd?: string;
+};
+
+type PreflightFlags = {
+  json?: boolean;
+  envFile?: string;
+  envModule?: string;
+  connect?: boolean;
+  serverModule?: string;
   cwd?: string;
 };
 
@@ -131,7 +143,7 @@ const databaseSchemaTableChoices = [
   "outbox",
 ] as const satisfies readonly DatabaseSchemaTable[];
 
-type DbSchemaGenerateFlags = DbFlags & {
+type DbSchemaSyncFlags = DbFlags & {
   dialect?: DatabaseSchemaDialect;
   tables?: readonly DatabaseSchemaTable[];
   output?: string;
@@ -278,14 +290,14 @@ const dbFlagParameters = {
   dryRun: dryRunFlag,
 } satisfies FlagParametersForType<DbFlags, CliContext>;
 
-const dbSchemaGenerateFlagParameters = {
+const dbSchemaSyncFlagParameters = {
   ...dbFlagParameters,
   dialect: {
     kind: "enum",
     values: databaseSchemaDialectChoices,
     optional: true,
     brief:
-      "Drizzle dialect to generate for. Inferred from server/providers.ts when omitted.",
+      "Drizzle dialect to sync. Inferred from server/providers.ts when omitted.",
   },
   tables: {
     kind: "enum",
@@ -293,12 +305,12 @@ const dbSchemaGenerateFlagParameters = {
     optional: true,
     variadic: ",",
     brief:
-      "Provider tables to generate as a comma-separated list. Defaults to audit,idempotency,outbox.",
+      "Provider tables to sync as a comma-separated list. Defaults to audit,idempotency,outbox.",
   },
   output: parsedStringFlag(
-    "Generated schema file. Defaults to infra/db/schema/beignet.ts.",
+    "Synced schema file. Defaults to infra/db/schema/beignet.ts.",
   ),
-} satisfies FlagParametersForType<DbSchemaGenerateFlags, CliContext>;
+} satisfies FlagParametersForType<DbSchemaSyncFlags, CliContext>;
 
 const taskRunFlagParameters = {
   json: jsonFlag,
@@ -400,7 +412,11 @@ and a shadcn UI shell. Pass --api for an API-only scaffold without the
 UI shell, and --db to choose the database.
 
 Available databases: ${databaseChoices.join(", ")}
-Available integrations: ${integrationChoices.join(", ")}
+Available integrations: ${createIntegrationChoices.join(", ")}
+
+--integrations accepts the starter template integrations plus the full
+beignet providers add preset catalog; presets are applied to the scaffold
+with the same machinery as beignet providers add.
 
 Running create on an interactive terminal without selection flags opens a
 prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
@@ -433,10 +449,11 @@ prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
       },
       integrations: {
         kind: "enum",
-        values: integrationChoices,
+        values: createIntegrationChoices,
         optional: true,
         variadic: ",",
-        brief: "Add first-party integrations as a comma-separated list.",
+        brief:
+          "Add first-party integrations or provider presets as a comma-separated list.",
       },
       yes: {
         kind: "boolean",
@@ -504,7 +521,18 @@ prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
 
       const api = selections.api ?? false;
       const database = selections.db ?? "sqlite";
-      const integrations = uniqueValues([...(selections.integrations ?? [])]);
+      const { integrations, presets } = splitCreateIntegrations(
+        uniqueValues([...(selections.integrations ?? [])]),
+      );
+
+      let presetsNeedEnv = false;
+      if (presets.length > 0) {
+        const { assertCompatibleCreatePresets, providerPresetNeedsEnv } =
+          await import("./provider-add.js");
+        assertCompatibleCreatePresets(presets, integrations);
+        presetsNeedEnv = presets.some(providerPresetNeedsEnv);
+      }
+
       const result = await createProject({
         name: selections.directory,
         template: flags.template,
@@ -516,11 +544,24 @@ prompt-based setup. Pass --yes or any selection flag to skip the prompts.`,
         dryRun: Boolean(flags.dryRun),
       });
 
+      if (!flags.dryRun && presets.length > 0) {
+        const { addProviderPreset } = await import("./provider-add.js");
+        for (const preset of presets) {
+          await addProviderPreset({ name: preset, cwd: result.targetDir });
+        }
+      }
+
       writeOutput(
         this,
         flags.json
-          ? JSON.stringify(result, null, 2)
-          : nextSteps(result, { api, integrations, database }),
+          ? JSON.stringify({ ...result, providerPresets: presets }, null, 2)
+          : nextSteps(result, {
+              api,
+              integrations,
+              database,
+              presets,
+              presetsNeedEnv,
+            }),
       );
     };
   },
@@ -622,6 +663,12 @@ const checkCommand = buildCommand<CheckFlags, [], CliContext>({
         withNegated: false,
         brief: "Apply low-risk doctor fixes before checking.",
       },
+      preflight: {
+        kind: "boolean",
+        optional: true,
+        withNegated: false,
+        brief: "Append a beignet preflight step after doctor.",
+      },
       cwd: cwdFlag,
     } satisfies FlagParametersForType<CheckFlags, CliContext>,
   },
@@ -635,6 +682,7 @@ const checkCommand = buildCommand<CheckFlags, [], CliContext>({
       const result = await checkApp({
         cwd: flags.cwd,
         fix: flags.fix,
+        preflight: flags.preflight,
         color,
         ...(flags.json
           ? {}
@@ -656,6 +704,64 @@ const checkCommand = buildCommand<CheckFlags, [], CliContext>({
   },
 });
 
+const preflightCommand = buildCommand<PreflightFlags, [], CliContext>({
+  docs: {
+    brief: "Validate the deploy environment before shipping.",
+    fullDescription:
+      "Runtime production gate, unlike the static doctor checks: reads the actual environment the process runs with, verifies every env var installed provider manifests mark as required, flags values still matching .env.example or common placeholders on secret-like keys, and validates the app env schema by importing lib/env.ts. Run it in the deploy pipeline where production configuration is present. Exits 1 on any error finding.",
+  },
+  parameters: {
+    flags: {
+      json: jsonFlag,
+      envFile: parsedStringFlag(
+        "Dotenv-style file merged under the environment (existing env keys win) for local rehearsal.",
+      ),
+      envModule: parsedStringFlag(
+        "App env module validated by importing it. Defaults to lib/env.ts.",
+      ),
+      connect: {
+        kind: "boolean",
+        optional: true,
+        withNegated: false,
+        brief:
+          "Boot the app server and run every port's checkHealth(). Needs network and real credentials.",
+      },
+      serverModule: parsedStringFlag(
+        "Module exporting getServer, used by --connect. Defaults to server/index.ts.",
+      ),
+      cwd: cwdFlag,
+    } satisfies FlagParametersForType<PreflightFlags, CliContext>,
+  },
+  loader: async () => {
+    const { formatPreflight, runPreflight } = await import("./preflight.js");
+    const path = await import("node:path");
+
+    return async function runPreflightCommand(
+      this: CliContext,
+      flags: PreflightFlags,
+    ) {
+      const cwd = path.resolve(flags.cwd ?? process.cwd());
+      const result = await runPreflight({
+        cwd,
+        envFile: flags.envFile,
+        envModule: flags.envModule,
+        connect: flags.connect,
+        serverModule: flags.serverModule,
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify({ schemaVersion: 1, cwd, ...result }, null, 2)
+          : formatPreflight(result, cwd),
+      );
+      if (result.findings.some((finding) => finding.severity === "error")) {
+        this.process.exitCode = 1;
+      }
+    };
+  },
+});
+
 const lintCommand = buildCommand<LintFlags, [], CliContext>({
   docs: {
     brief: "Check Beignet dependency direction conventions.",
@@ -819,27 +925,23 @@ function databaseCommand(command: DatabaseCommandName) {
   });
 }
 
-const dbSchemaGenerateCommand = buildCommand<
-  DbSchemaGenerateFlags,
-  [],
-  CliContext
->({
+const dbSchemaSyncCommand = buildCommand<DbSchemaSyncFlags, [], CliContext>({
   docs: {
-    brief: "Generate provider-owned Drizzle schema exports.",
+    brief: "Sync app-owned re-exports of Beignet provider tables.",
     fullDescription:
-      "Writes an app-owned schema file that re-exports Beignet provider tables, then updates the schema index. Run beignet db generate afterward to let the app's Drizzle Kit script create migrations.",
+      "Idempotently brings the app-owned schema file that re-exports Beignet provider tables in sync with the installed providers, then updates the schema index. Run beignet db generate afterward to let the app's Drizzle Kit script create migrations.",
   },
   parameters: {
-    flags: dbSchemaGenerateFlagParameters,
+    flags: dbSchemaSyncFlagParameters,
   },
   loader: async () => {
-    const { generateDatabaseSchema } = await import("./db.js");
+    const { syncDatabaseSchema } = await import("./db.js");
 
-    return async function runDbSchemaGenerate(
+    return async function runDbSchemaSync(
       this: CliContext,
-      flags: DbSchemaGenerateFlags,
+      flags: DbSchemaSyncFlags,
     ) {
-      const result = await generateDatabaseSchema({
+      const result = await syncDatabaseSchema({
         dialect: flags.dialect,
         tables: flags.tables,
         output: flags.output,
@@ -850,7 +952,7 @@ const dbSchemaGenerateCommand = buildCommand<
         this,
         flags.json
           ? JSON.stringify(result, null, 2)
-          : databaseSchemaGenerateNextSteps(result),
+          : databaseSchemaSyncNextSteps(result),
       );
     };
   },
@@ -858,10 +960,10 @@ const dbSchemaGenerateCommand = buildCommand<
 
 const dbSchemaRoutes = buildRouteMap({
   docs: {
-    brief: "Generate Beignet database schema helpers.",
+    brief: "Sync app-owned Beignet provider schema exports.",
   },
   routes: {
-    generate: dbSchemaGenerateCommand,
+    sync: dbSchemaSyncCommand,
   },
 });
 
@@ -1557,6 +1659,7 @@ Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
     make: makeRoutes,
     mcp: mcpCommand,
     outbox: outboxRoutes,
+    preflight: preflightCommand,
     providers: providerRoutes,
     routes: routesCommand,
     schedule: scheduleRoutes,
@@ -1626,7 +1729,7 @@ type DatabaseCommandNextStepsResult = {
   dryRun: boolean;
 };
 
-type DatabaseSchemaGenerateNextStepsResult = {
+type DatabaseSchemaSyncNextStepsResult = {
   cwd: string;
   dialect: DatabaseSchemaDialect;
   tables: DatabaseSchemaTable[];
@@ -1708,15 +1811,23 @@ function nextSteps(
     api?: boolean;
     integrations?: readonly IntegrationName[];
     database?: DatabaseName;
+    presets?: readonly ProviderPresetName[];
+    presetsNeedEnv?: boolean;
   } = {},
 ): string {
   if (result.dryRun) {
     const plannedFiles = result.files.map((file) => `  ${file}`).join("\n");
+    const plannedPresets =
+      options.presets && options.presets.length > 0
+        ? `\n\nProvider presets applied after scaffold (skipped in dry run):\n${options.presets
+            .map((preset) => `  ${preset}`)
+            .join("\n")}`
+        : "";
 
     return `Would create ${result.name} at ${result.targetDir}
 
 Planned files:
-${plannedFiles}`;
+${plannedFiles}${plannedPresets}`;
   }
 
   const pm = result.packageManager;
@@ -1725,9 +1836,17 @@ ${plannedFiles}`;
   const envRequiredIntegrations =
     options.integrations?.filter(isEnvRequiredProviderIntegration) ?? [];
   const envStep =
-    envRequiredIntegrations.length > 0
+    envRequiredIntegrations.length > 0 || options.presetsNeedEnv
       ? "  Fill .env.local for selected provider integrations before starting the app.\n"
       : "";
+  const presetSection =
+    options.presets && options.presets.length > 0
+      ? `\nProvider presets applied:\n${options.presets
+          .map((preset) => `  ${preset}`)
+          .join(
+            "\n",
+          )}\n  See docs/integrations.md for setup notes and follow-up steps.\n`
+      : "";
   const openStep = options.api
     ? "  open http://localhost:3000 for the API landing page"
     : "  open http://localhost:3000/sign-up";
@@ -1742,7 +1861,7 @@ ${plannedFiles}`;
     : "";
 
   return `Created ${result.name} at ${result.targetDir}
-
+${presetSection}
 Next steps:
   cd ${result.targetDir}
   ${pm} install
@@ -1858,15 +1977,15 @@ Command:
   ${command}`;
 }
 
-function databaseSchemaGenerateNextSteps(
-  result: DatabaseSchemaGenerateNextStepsResult,
+function databaseSchemaSyncNextSteps(
+  result: DatabaseSchemaSyncNextStepsResult,
 ): string {
   const { changedFiles, skippedFiles } = changedFileLines({
     createdFiles: result.createdFiles,
     updatedFiles: result.updatedFiles,
     skippedFiles: result.skippedFiles,
   });
-  const prefix = result.dryRun ? "Would generate" : "Generated";
+  const prefix = result.dryRun ? "Would sync" : "Synced";
   const tables = result.tables.join(", ");
 
   return `${prefix} Beignet ${result.dialect} database schema (${tables}) in ${result.cwd}