@beignet/cli 0.0.38 → 0.0.39

package/skills/app-structure/SKILL.md

@@ -34,19 +34,24 @@ Use:
 ```bash
 beignet make feature projects
 beignet make feature projects --recipe full-slice
-beignet make resource projects/project --auth --tenant
-beignet make event posts/published
-beignet make listener posts/enqueue-published-email --event posts/published
-beignet make job billing/sync
-beignet make schedule billing/nightly --cron "0 2 * * *"
-beignet make task admin/backfill
-beignet make seed demo/users
-beignet make upload issues/attachment
+beignet make resource projects --authorization --tenant-scoped
+beignet make event posts.published
+beignet make listener posts.enqueue-published-email --event posts.published
+beignet make job billing.sync
+beignet make schedule billing.nightly --cron "0 2 * * *"
+beignet make task admin.backfill
+beignet make seed demo.users
+beignet make upload issues.attachment
+beignet make upload issues.attachment --ui
 ```
 
 Generators place files under the owning feature, update central registries
 when possible, and keep `doctor` clean.
 
+Use `make upload --ui` in full-stack apps when the upload should include a
+shared client/server constraint manifest, typed React upload client, uploader,
+and component test. Omit `--ui` for API-only or backend-only workflows.
+
 Use the `full-slice` recipe when you need a richer reference feature with
 policy, client helpers, workflow artifacts, events, listener registration,
 jobs, schedules, notifications, uploads, seeds, and outbox wiring. After

package/src/choices.ts

@@ -14,18 +14,21 @@ export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
  */
 export type TemplateName = "next";
 /**
- * Optional provider integrations that can be scaffolded into a new app.
+ * Optional providers rendered directly by the starter template.
  *
  * Better Auth, Drizzle/libSQL, and pino ship in every starter, so only
- * integrations that add an external service remain selectable.
+ * providers that add an external service remain selectable.
  */
-export type IntegrationName = "inngest" | "resend" | "upstash-rate-limit";
+export type StarterProviderName =
+  | "jobs-inngest"
+  | "mail-resend"
+  | "rate-limit-upstash";
 /**
  * Databases supported by the starter's Drizzle persistence layer.
  */
 export type DatabaseName = "sqlite" | "postgres" | "mysql";
 /**
- * Provider setup presets supported by `beignet providers add`.
+ * Provider setup presets supported by `beignet provider add`.
  */
 export type ProviderPresetName =
   | "flags-openfeature"
@@ -35,13 +38,13 @@ export type ProviderPresetName =
   | "mail-smtp"
   | "payments-stripe"
   | "search-meilisearch"
-  | "sentry"
-  | "upstash-rate-limit"
-  | "redis-cache"
+  | "error-reporting-sentry"
+  | "rate-limit-upstash"
+  | "cache-redis"
   | "event-bus-redis"
-  | "redis-locks"
-  | "s3-storage"
-  | "vercel-blob-storage";
+  | "locks-redis"
+  | "storage-s3"
+  | "storage-vercel-blob";
 
 /**
  * Supported scaffold template choices.
@@ -61,13 +64,13 @@ export const packageManagerChoices = [
 ] as const satisfies readonly PackageManager[];
 
 /**
- * Supported scaffold integration choices.
+ * Supported providers rendered directly by the starter.
  */
-export const integrationChoices = [
-  "inngest",
-  "resend",
-  "upstash-rate-limit",
-] as const satisfies readonly IntegrationName[];
+export const starterProviderChoices = [
+  "jobs-inngest",
+  "mail-resend",
+  "rate-limit-upstash",
+] as const satisfies readonly StarterProviderName[];
 
 /**
  * Supported scaffold database choices.
@@ -89,89 +92,45 @@ export const providerPresetChoices = [
   "mail-smtp",
   "payments-stripe",
   "search-meilisearch",
-  "sentry",
-  "upstash-rate-limit",
-  "redis-cache",
+  "error-reporting-sentry",
+  "rate-limit-upstash",
+  "cache-redis",
   "event-bus-redis",
-  "redis-locks",
-  "s3-storage",
-  "vercel-blob-storage",
+  "locks-redis",
+  "storage-s3",
+  "storage-vercel-blob",
 ] as const satisfies readonly ProviderPresetName[];
 
 /**
- * Values accepted by `beignet create --integrations`: the starter template
- * integrations plus the full `beignet providers add` preset catalog.
+ * Values accepted by `beignet create --providers`.
  */
-export type CreateIntegrationName = IntegrationName | ProviderPresetName;
+export type CreateProviderName = ProviderPresetName;
 
 /**
- * Supported `beignet create --integrations` choices. Template integrations
- * come first; the rest of the provider preset catalog follows.
+ * Supported `beignet create --providers` choices.
  */
-export const createIntegrationChoices = [
-  "inngest",
-  "resend",
-  "upstash-rate-limit",
-  "flags-openfeature",
-  "jobs-bullmq",
-  "jobs-inngest",
-  "mail-resend",
-  "mail-smtp",
-  "payments-stripe",
-  "redis-cache",
-  "event-bus-redis",
-  "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",
-};
+export const createProviderChoices = providerPresetChoices;
 
 /**
- * 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.
+ * Split `--providers` selections into providers rendered directly by the
+ * starter and presets applied after the scaffold is written.
  */
-export function splitCreateIntegrations(
-  values: readonly CreateIntegrationName[],
-): {
-  integrations: IntegrationName[];
+export function splitCreateProviders(values: readonly CreateProviderName[]): {
+  starterProviders: StarterProviderName[];
   presets: ProviderPresetName[];
 } {
-  const integrations = new Set<IntegrationName>();
+  const starterProviders = new Set<StarterProviderName>();
   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);
+    if ((starterProviderChoices as readonly string[]).includes(value)) {
+      starterProviders.add(value as StarterProviderName);
     } else {
-      presets.add(preset);
+      presets.add(value);
     }
   }
 
-  return { integrations: [...integrations], presets: [...presets] };
+  return { starterProviders: [...starterProviders], presets: [...presets] };
 }
 
 /**
@@ -246,24 +205,15 @@ export const completionShellChoices = [
 export const makeFeatureAddonChoices = [
   "policy",
   "factory",
-  "factories",
   "event",
-  "events",
   "job",
-  "jobs",
   "listener",
-  "listeners",
   "notification",
-  "notifications",
   "schedule",
-  "schedules",
   "seed",
-  "seeds",
   "task",
-  "tasks",
   "ui",
   "upload",
-  "uploads",
 ] as const;
 
 /**

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 {