@beignet/cli 0.0.26 → 0.0.27

package/src/index.ts

@@ -26,12 +26,15 @@ import {
   makeFeatureAddonChoices,
   makeFeatureRecipeChoices,
   type PackageManager,
+  type ProviderPresetName,
   packageManagerChoices,
+  providerPresetChoices,
   type TemplateName,
   templateChoices,
 } from "./choices.js";
 // Type-only: the runtime module stays behind the create command's lazy loader.
 import type { CreateSelections } from "./create-prompts.js";
+import type { AddProviderPresetResult } from "./provider-add.js";
 import { getCliVersion } from "./version.js";
 
 type CliContext = CommandContext & {
@@ -131,6 +134,7 @@ type DbSchemaGenerateFlags = DbFlags & {
 type TaskRunFlags = {
   json?: boolean;
   input?: string;
+  tenant?: string;
   module?: string;
 };
 
@@ -168,7 +172,24 @@ type ProviderAuditFlags = {
   cwd?: string;
 };
 
+type ProviderAddFlags = {
+  json?: boolean;
+  dryRun?: boolean;
+  cwd?: string;
+};
+
 const parseString = (input: string): string => input;
+const parseProviderPreset = (input: string): ProviderPresetName => {
+  if ((providerPresetChoices as readonly string[]).includes(input)) {
+    return input as ProviderPresetName;
+  }
+
+  throw new Error(
+    `Unknown provider preset "${input}". Available presets: ${providerPresetChoices.join(
+      ", ",
+    )}.`,
+  );
+};
 const parsePositiveInteger = (input: string): number => {
   const value = Number(input);
   if (!Number.isInteger(value) || value <= 0) {
@@ -240,6 +261,12 @@ const providerAuditFlagParameters = {
   cwd: cwdFlag,
 } satisfies FlagParametersForType<ProviderAuditFlags, CliContext>;
 
+const providerAddFlagParameters = {
+  json: jsonFlag,
+  dryRun: dryRunFlag,
+  cwd: cwdFlag,
+} satisfies FlagParametersForType<ProviderAddFlags, CliContext>;
+
 const dbFlagParameters = {
   json: jsonFlag,
   dryRun: dryRunFlag,
@@ -270,6 +297,9 @@ const dbSchemaGenerateFlagParameters = {
 const taskRunFlagParameters = {
   json: jsonFlag,
   input: parsedStringFlag("JSON input passed to the task schema."),
+  tenant: parsedStringFlag(
+    "Tenant id or slug passed to the app's createTaskContext, separate from task input.",
+  ),
   module: parsedStringFlag(
     "Task registry module. Defaults to server/tasks.ts.",
   ),
@@ -317,6 +347,19 @@ const namePositional = {
   ],
 } as const;
 
+const providerPresetPositional = {
+  kind: "tuple",
+  parameters: [
+    {
+      parse: parseProviderPreset,
+      placeholder: "preset",
+      brief: `Provider preset to add. Available: ${providerPresetChoices.join(
+        ", ",
+      )}.`,
+    },
+  ],
+} as const;
+
 function resolveOutputFormat(flags: {
   json?: boolean;
   format?: OutputFormat;
@@ -639,11 +682,50 @@ const providerAuditCommand = buildCommand<ProviderAuditFlags, [], CliContext>({
   },
 });
 
+const providerAddCommand = buildCommand<
+  ProviderAddFlags,
+  [ProviderPresetName],
+  CliContext
+>({
+  docs: {
+    brief: "Add a provider setup preset to a Beignet app.",
+    fullDescription: `Updates an existing Beignet app with provider package dependencies, server/provider registration, app port wiring, .env.example entries, and local setup notes.
+
+Available presets: ${providerPresetChoices.join(", ")}`,
+  },
+  parameters: {
+    flags: providerAddFlagParameters,
+    positional: providerPresetPositional,
+  },
+  loader: async () => {
+    const { addProviderPreset } = await import("./provider-add.js");
+
+    return async function runProviderAdd(
+      this: CliContext,
+      flags: ProviderAddFlags,
+      name: ProviderPresetName,
+    ) {
+      const result = await addProviderPreset({
+        name,
+        cwd: flags.cwd,
+        dryRun: Boolean(flags.dryRun),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : providerAddNextSteps(result),
+      );
+    };
+  },
+});
+
 const providerRoutes = buildRouteMap({
   docs: {
-    brief: "Inspect Beignet provider setup.",
+    brief: "Manage Beignet provider setup.",
   },
   routes: {
+    add: providerAddCommand,
     audit: providerAuditCommand,
   },
 });
@@ -760,6 +842,7 @@ const taskRunCommand = buildCommand<TaskRunFlags, [string], CliContext>({
       const result = await runAppTask({
         name,
         input: flags.input,
+        tenant: flags.tenant,
         modulePath: flags.module,
       });
 
@@ -1215,7 +1298,9 @@ const makePaymentsCommand = buildCommand<MakeFlags, [], CliContext>({
     flags: makeFlagParameters,
   },
   loader: async () => {
-    const { makePayments } = await import("./make.js");
+    const { makePayments, makePaymentsNextStepLines } = await import(
+      "./make.js"
+    );
 
     return async function runMakePayments(this: CliContext, flags: MakeFlags) {
       const result = await makePayments({
@@ -1226,7 +1311,69 @@ const makePaymentsCommand = buildCommand<MakeFlags, [], CliContext>({
         this,
         flags.json
           ? JSON.stringify(result, null, 2)
-          : makePaymentsNextSteps(result),
+          : makeNextSteps(
+              result,
+              "billing slice",
+              makePaymentsNextStepLines(result),
+            ),
+      );
+    };
+  },
+});
+
+const makeTenancyCommand = buildCommand<MakeFlags, [], CliContext>({
+  docs: {
+    brief: "Generate a workspace tenancy slice.",
+  },
+  parameters: {
+    flags: makeFlagParameters,
+  },
+  loader: async () => {
+    const { makeTenancy, makeTenancyNextStepLines } = await import("./make.js");
+
+    return async function runMakeTenancy(this: CliContext, flags: MakeFlags) {
+      const result = await makeTenancy({
+        force: Boolean(flags.force),
+        dryRun: Boolean(flags.dryRun),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : makeNextSteps(
+              result,
+              "workspace slice",
+              makeTenancyNextStepLines(),
+            ),
+      );
+    };
+  },
+});
+
+const makeInboxCommand = buildCommand<MakeFlags, [], CliContext>({
+  docs: {
+    brief: "Generate an in-app inbox notifications slice.",
+  },
+  parameters: {
+    flags: makeFlagParameters,
+  },
+  loader: async () => {
+    const { makeInbox, makeInboxNextStepLines } = await import("./make.js");
+
+    return async function runMakeInbox(this: CliContext, flags: MakeFlags) {
+      const result = await makeInbox({
+        force: Boolean(flags.force),
+        dryRun: Boolean(flags.dryRun),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : makeNextSteps(
+              result,
+              "notifications slice",
+              makeInboxNextStepLines(),
+            ),
       );
     };
   },
@@ -1283,6 +1430,7 @@ const makeRoutes = buildRouteMap({
       makeFactoryNextSteps,
     ),
     feature: makeFeatureCommand,
+    inbox: makeInboxCommand,
     job: simpleMakeCommand(
       "makeJob",
       "Generate a feature job.",
@@ -1318,6 +1466,7 @@ const makeRoutes = buildRouteMap({
       "Generate a feature operational task.",
       makeTaskNextSteps,
     ),
+    tenancy: makeTenancyCommand,
     test: simpleMakeCommand(
       "makeTest",
       "Generate a use case test.",
@@ -1432,6 +1581,7 @@ type DatabaseSchemaGenerateNextStepsResult = {
 type AppTaskRunNextStepsResult = {
   name: string;
   durationMs: number;
+  tenant?: string;
   output: unknown;
 };
 
@@ -1463,7 +1613,9 @@ function appTaskRunNextSteps(result: AppTaskRunNextStepsResult): string {
       ? "undefined"
       : JSON.stringify(result.output, null, 2);
 
-  return `Ran task ${result.name} in ${result.durationMs}ms
+  const tenant = result.tenant ? `\nTenant: ${result.tenant}` : "";
+
+  return `Ran task ${result.name} in ${result.durationMs}ms${tenant}
 
 Output:
 ${output}`;
@@ -1617,6 +1769,20 @@ Next steps:
 ${steps.map((step) => `  ${step}`).join("\n")}`;
 }
 
+function providerAddNextSteps(result: AddProviderPresetResult): string {
+  const { changedFiles, skippedFiles } = changedFileLines(result);
+  const prefix = result.dryRun ? "Would add" : "Added";
+
+  return `${prefix} ${result.name} provider preset in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+${result.nextSteps.map((step) => `  ${step}`).join("\n")}`;
+}
+
 function makeResourceNextSteps(result: MakeNextStepsResult): string {
   return makeNextSteps(result, "resource", [
     "Use make resource when the feature maps cleanly to a REST resource with repository-backed persistence.",
@@ -1754,15 +1920,6 @@ function makeNotificationNextSteps(result: MakeNextStepsResult): string {
   ]);
 }
 
-function makePaymentsNextSteps(result: MakeNextStepsResult): string {
-  return makeNextSteps(result, "billing slice", [
-    "Set BILLING_TEAM_PRICE_ID in .env.local to the provider price ID for your team plan.",
-    "Run beignet db generate and beignet db migrate so billing_accounts exists before handling webhooks.",
-    "Use createMemoryPaymentsProvider() for local development, then swap server/providers.ts to stripePaymentsProvider when STRIPE_SECRET_KEY and STRIPE_WEBHOOK_SECRET are configured.",
-    "Run your app's test, lint, and typecheck commands, then beignet lint and beignet doctor.",
-  ]);
-}
-
 function makeOutboxNextSteps(result: MakeNextStepsResult): string {
   return makeNextSteps(result, "outbox runtime", [
     "Set CRON_SECRET in your deployment and call /api/cron/outbox/drain from a scheduler with Authorization: Bearer $CRON_SECRET.",

package/src/inspect.ts

@@ -986,6 +986,24 @@ function parseRouteExports(
   const imports = parseNamedImports(source, config);
   const exportRegex =
     /export const\s+(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*=\s*([^;\n]+)/g;
+  const apiRouteExportRegex =
+    /export const\s*\{([^}]+)\}\s*=\s*createApiRoute\s*\(/g;
+
+  for (const match of source.matchAll(apiRouteExportRegex)) {
+    for (const member of match[1].split(",")) {
+      const parts = member.split(":");
+      const method = (parts[1] ?? parts[0])?.trim();
+      if (!method || !isHttpMethod(method)) continue;
+
+      exports.push({
+        method,
+        handlerFile,
+        contractRef: routePath,
+        catchAllPrefix: catchAllRoutePrefix(routePath),
+        source: "next-route",
+      });
+    }
+  }
 
   for (const match of source.matchAll(exportRegex)) {
     const method = match[1] as HttpMethod;
@@ -1384,7 +1402,7 @@ async function inspectDiagnostics(
       convention,
       contracts,
     )),
-    ...(await inspectServerlessFootguns(targetDir, files)),
+    ...(await inspectServerlessFootguns(targetDir, files, config, convention)),
     ...(await inspectProductionReadiness(targetDir, files, config, convention)),
     ...(await inspectFeatureArtifactDrift(
       targetDir,
@@ -3773,6 +3791,8 @@ function isWorkflowTestFile(file: string): boolean {
 async function inspectServerlessFootguns(
   targetDir: string,
   files: string[],
+  config: ResolvedBeignetConfig,
+  convention: InspectConvention,
 ): Promise<InspectDiagnostic[]> {
   const diagnostics: InspectDiagnostic[] = [];
 
@@ -3792,6 +3812,19 @@ async function inspectServerlessFootguns(
       /(^|\/)[^/]*provider[^/]*\.ts$/.test(file);
     const source = await readFile(path.join(targetDir, file), "utf8");
 
+    if (
+      convention.resourceGenerator &&
+      isNextRouteFile(file, config) &&
+      importsEagerServer(source, file, files, config)
+    ) {
+      diagnostics.push({
+        severity: "warning",
+        code: "BEIGNET_NEXT_ROUTE_EAGER_SERVER_IMPORT",
+        file,
+        message: `${file} imports the eager server singleton. Next.js imports route modules during production builds, so use createNextServerLoader(...) in ${config.paths.server} and pass getServer to createApiRoute(...), createHealthRoute(...), or the focused route helper instead.`,
+      });
+    }
+
     if (
       isInfraOrServerFile &&
       isProviderFile &&
@@ -3850,6 +3883,37 @@ async function inspectServerlessFootguns(
   return diagnostics;
 }
 
+function isNextRouteFile(file: string, config: ResolvedBeignetConfig): boolean {
+  const routesPath = directoryPath(config.paths.routes);
+
+  return (
+    file.startsWith(`${routesPath}/`) &&
+    file.endsWith("/route.ts") &&
+    !file.endsWith(".test.ts")
+  );
+}
+
+function importsEagerServer(
+  source: string,
+  importerFile: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): boolean {
+  const importRegex = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
+
+  for (const match of source.matchAll(importRegex)) {
+    const members = match[1]
+      .split(",")
+      .map((member) => parseImportMember(member));
+    if (!members.some((member) => member?.importedName === "server")) continue;
+
+    const sourceFile = sourceFileFromImport(match[2], importerFile, files);
+    if (sourceFile === config.paths.server) return true;
+  }
+
+  return false;
+}
+
 function hasOutboxRegistry(files: string[]): boolean {
   return files.some(isOutboxRegistryFile);
 }
@@ -4076,7 +4140,9 @@ async function inspectDatabaseLifecycleDrift(
     {
       script: "db:seed",
       command: "seed",
-      file: `${infrastructurePath}/db/seed.ts`,
+      // The seed entrypoint lives beside the server runtime because it boots
+      // the app through getServer(), which infra/ must not import.
+      file: `${directoryPath(path.dirname(config.paths.server))}/seed.ts`,
       code: "BEIGNET_DB_SEED_ENTRYPOINT_MISSING",
     },
     {