@beignet/cli 0.0.15 → 0.0.17

package/src/make.ts

@@ -37,10 +37,14 @@ export { makeFeatureAddonChoices } from "./choices.js";
 
 type NormalizedMakeFeatureAddon =
   | "policy"
+  | "factory"
   | "task"
   | "event"
   | "job"
+  | "listener"
   | "notification"
+  | "schedule"
+  | "seed"
   | "ui"
   | "upload";
 
@@ -126,6 +130,7 @@ type MakeFactoryOptions = {
   force?: boolean;
   dryRun?: boolean;
   config?: BeignetConfig;
+  skipPersistenceAssert?: boolean;
 };
 
 type MakeSeedOptions = {
@@ -134,6 +139,7 @@ type MakeSeedOptions = {
   force?: boolean;
   dryRun?: boolean;
   config?: BeignetConfig;
+  skipPersistenceAssert?: boolean;
 };
 
 type MakeNotificationOptions = {
@@ -151,6 +157,7 @@ type MakeListenerOptions = {
   force?: boolean;
   dryRun?: boolean;
   config?: BeignetConfig;
+  skipEventAssert?: boolean;
 };
 
 type MakeScheduleOptions = {
@@ -172,6 +179,13 @@ type MakeUploadOptions = {
   config?: BeignetConfig;
 };
 
+type MakeOutboxOptions = {
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
 type MakePaymentsOptions = {
   cwd?: string;
   force?: boolean;
@@ -258,6 +272,10 @@ export type MakeScheduleResult = MakeResult;
  * Result returned by `beignet make upload`.
  */
 export type MakeUploadResult = MakeResult;
+/**
+ * Result returned by `beignet make outbox`.
+ */
+export type MakeOutboxResult = MakeResult;
 /**
  * Result returned by `beignet make payments`.
  */
@@ -742,6 +760,13 @@ async function makeFeatureAddon(
   if (addon === "policy") {
     return makePolicy({ ...shared, name: feature });
   }
+  if (addon === "factory") {
+    return makeFactory({
+      ...shared,
+      name: `${feature}/${singularize(feature)}`,
+      skipPersistenceAssert: true,
+    });
+  }
   if (addon === "task") {
     return makeTask({ ...shared, name: `${feature}/backfill` });
   }
@@ -751,9 +776,27 @@ async function makeFeatureAddon(
   if (addon === "job") {
     return makeJob({ ...shared, name: `${feature}/process` });
   }
+  if (addon === "listener") {
+    return makeListener({
+      ...shared,
+      name: `${feature}/handle-created`,
+      event: `${feature}/created`,
+      skipEventAssert: true,
+    });
+  }
   if (addon === "notification") {
     return makeNotification({ ...shared, name: `${feature}/created` });
   }
+  if (addon === "schedule") {
+    return makeSchedule({ ...shared, name: `${feature}/daily-summary` });
+  }
+  if (addon === "seed") {
+    return makeSeed({
+      ...shared,
+      name: `${feature}/demo-${feature}`,
+      skipPersistenceAssert: true,
+    });
+  }
   if (addon === "ui") {
     return makeFeatureUi({ ...shared, name: feature });
   }
@@ -767,12 +810,21 @@ function normalizeMakeFeatureAddons(
   const normalized = new Set<NormalizedMakeFeatureAddon>();
 
   for (const addon of addons) {
-    if (addon === "events") normalized.add("event");
-    else if (addon === "tasks") normalized.add("task");
+    if (addon === "factories") normalized.add("factory");
+    else if (addon === "events") normalized.add("event");
+    else if (addon === "listeners") {
+      normalized.add("event");
+      normalized.add("listener");
+    } else if (addon === "tasks") normalized.add("task");
     else if (addon === "jobs") normalized.add("job");
     else if (addon === "notifications") normalized.add("notification");
+    else if (addon === "schedules") normalized.add("schedule");
+    else if (addon === "seeds") normalized.add("seed");
     else if (addon === "uploads") normalized.add("upload");
-    else normalized.add(addon);
+    else if (addon === "listener") {
+      normalized.add("event");
+      normalized.add("listener");
+    } else normalized.add(addon);
   }
 
   return featureAddonOrder.filter((addon) => normalized.has(addon));
@@ -780,10 +832,14 @@ function normalizeMakeFeatureAddons(
 
 const featureAddonOrder: readonly NormalizedMakeFeatureAddon[] = [
   "policy",
+  "factory",
   "task",
   "event",
   "job",
+  "listener",
   "notification",
+  "schedule",
+  "seed",
   "ui",
   "upload",
 ];
@@ -798,6 +854,22 @@ function mergeMakeResults(left: MakeResult, right: MakeResult): MakeResult {
   };
 }
 
+function mergeMakeResultInto(target: MakeResult, source: MakeResult): void {
+  target.files = uniqueStrings([...target.files, ...source.files]);
+  target.createdFiles = uniqueStrings([
+    ...target.createdFiles,
+    ...source.createdFiles,
+  ]);
+  target.updatedFiles = uniqueStrings([
+    ...target.updatedFiles,
+    ...source.updatedFiles,
+  ]);
+  target.skippedFiles = uniqueStrings([
+    ...target.skippedFiles,
+    ...source.skippedFiles,
+  ]);
+}
+
 function uniqueStrings(values: readonly string[]): string[] {
   return [...new Set(values)];
 }
@@ -1086,6 +1158,8 @@ export async function makeEvent(
     : await loadBeignetConfig(targetDir);
 
   await assertFeatureArtifactApp(targetDir, config, "event");
+  await assertServerRuntimeApp(targetDir, config, "event");
+  await updateOutboxPortWiring(targetDir, config, { dryRun: true });
 
   // Events are published through ctx.ports.eventBus, so the generator wires
   // the port and an in-memory dev provider when the app has no bus yet. Plan
@@ -1095,6 +1169,9 @@ export async function makeEvent(
   await wirePortProviders(targetDir, config, eventBusWirings, {
     dryRun: true,
   });
+  const outboxDrainPlan = await planOutboxDrainWiring(targetDir, config, {
+    force: Boolean(options.force),
+  });
 
   const result = await makeFeatureArtifact({
     targetDir,
@@ -1112,6 +1189,12 @@ export async function makeEvent(
   await applyOutboxRegistryUpdate(result, targetDir, names, "events", config, {
     dryRun: Boolean(options.dryRun),
   });
+  await applyOutboxDrainWiring(result, targetDir, outboxDrainPlan, {
+    dryRun: Boolean(options.dryRun),
+  });
+  await applyOutboxPortWiring(result, targetDir, config, {
+    dryRun: Boolean(options.dryRun),
+  });
 
   await applyPortProviderWiring(result, targetDir, config, eventBusWirings, {
     dryRun: Boolean(options.dryRun),
@@ -1128,6 +1211,11 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
     : await loadBeignetConfig(targetDir);
 
   await assertFeatureArtifactApp(targetDir, config, "job");
+  await assertServerRuntimeApp(targetDir, config, "job");
+  await updateOutboxPortWiring(targetDir, config, { dryRun: true });
+  const outboxDrainPlan = await planOutboxDrainWiring(targetDir, config, {
+    force: Boolean(options.force),
+  });
 
   const result = await makeFeatureArtifact({
     targetDir,
@@ -1148,6 +1236,12 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   await applyOutboxRegistryUpdate(result, targetDir, names, "jobs", config, {
     dryRun: Boolean(options.dryRun),
   });
+  await applyOutboxDrainWiring(result, targetDir, outboxDrainPlan, {
+    dryRun: Boolean(options.dryRun),
+  });
+  await applyOutboxPortWiring(result, targetDir, config, {
+    dryRun: Boolean(options.dryRun),
+  });
 
   return result;
 }
@@ -1204,7 +1298,9 @@ export async function makeFactory(
     ? resolveConfig(options.config)
     : await loadBeignetConfig(targetDir);
 
-  await assertPersistenceArtifactApp(targetDir, names, config, "factory");
+  if (!options.skipPersistenceAssert) {
+    await assertPersistenceArtifactApp(targetDir, names, config, "factory");
+  }
 
   return makeFeatureArtifact({
     targetDir,
@@ -1229,9 +1325,11 @@ export async function makeSeed(
     ? resolveConfig(options.config)
     : await loadBeignetConfig(targetDir);
 
-  await assertPersistenceArtifactApp(targetDir, names, config, "seed");
+  if (!options.skipPersistenceAssert) {
+    await assertPersistenceArtifactApp(targetDir, names, config, "seed");
+  }
 
-  return makeFeatureArtifact({
+  const result = await makeFeatureArtifact({
     targetDir,
     config,
     force: Boolean(options.force),
@@ -1243,6 +1341,57 @@ export async function makeSeed(
       "@beignet/core": beignetDependencyVersion,
     },
   });
+
+  const factoryNamesForSeed = defaultFactoryNamesForSeed(names);
+  if (
+    !(await fileExists(
+      path.join(targetDir, factoryFilePath(factoryNamesForSeed, config)),
+    ))
+  ) {
+    const factoryResult = await makeFeatureArtifact({
+      targetDir,
+      config,
+      force: Boolean(options.force),
+      dryRun: Boolean(options.dryRun),
+      name: `${factoryNamesForSeed.feature.kebab}/${factoryNamesForSeed.artifact.kebab}`,
+      files: factoryFiles(factoryNamesForSeed, config),
+      index: featureArtifactIndexFile("factory", factoryNamesForSeed, config),
+      dependencies: {
+        "@beignet/core": beignetDependencyVersion,
+      },
+    });
+    mergeMakeResultInto(result, factoryResult);
+  }
+
+  const seedEntrypointResult = await updateSeedEntrypoint(
+    targetDir,
+    names,
+    config,
+    { dryRun: Boolean(options.dryRun) },
+  );
+  if (seedEntrypointResult === "created")
+    result.createdFiles.push(seedEntrypointPath(config));
+  if (seedEntrypointResult === "updated")
+    result.updatedFiles.push(seedEntrypointPath(config));
+  if (seedEntrypointResult === "skipped")
+    result.skippedFiles.push(seedEntrypointPath(config));
+  if (!result.files.includes(seedEntrypointPath(config))) {
+    result.files.push(seedEntrypointPath(config));
+  }
+
+  if (
+    await updatePackageScripts(
+      targetDir,
+      { "db:seed": `bun ${seedEntrypointPath(config)}` },
+      { dryRun: Boolean(options.dryRun) },
+    )
+  ) {
+    result.updatedFiles.push("package.json");
+    if (!result.files.includes("package.json"))
+      result.files.push("package.json");
+  }
+
+  return result;
 }
 
 export async function makeNotification(
@@ -1309,7 +1458,9 @@ export async function makeListener(
     : await loadBeignetConfig(targetDir);
 
   await assertFeatureArtifactApp(targetDir, config, "listener");
-  await assertListenerEventExists(targetDir, names.event, config);
+  if (!options.skipEventAssert) {
+    await assertListenerEventExists(targetDir, names.event, config);
+  }
 
   return makeFeatureArtifact({
     targetDir,
@@ -1518,6 +1669,253 @@ async function applyCronSecretWiring(
   };
 }
 
+type OutboxDrainWiringPlan = {
+  route: PlannedGeneratedFile;
+  cronSecret: CronSecretWiringPlan;
+};
+
+async function planOutboxDrainWiring(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { force: boolean },
+): Promise<OutboxDrainWiringPlan | undefined> {
+  if (await fileExists(path.join(targetDir, outboxDrainRoutePath(config)))) {
+    return undefined;
+  }
+
+  const route = await planGeneratedFile(
+    targetDir,
+    {
+      path: outboxDrainRoutePath(config),
+      content: outboxDrainRouteFile(config),
+    },
+    { force: options.force },
+  );
+
+  return {
+    route,
+    cronSecret: await planCronSecretWiring(targetDir),
+  };
+}
+
+async function updateOutboxPortWiring(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<string[]> {
+  const updated = new Set<string>();
+
+  if (await updateOutboxPorts(targetDir, config, options)) {
+    updated.add(config.paths.ports);
+  }
+  if (await updateOutboxInfrastructurePorts(targetDir, config, options)) {
+    updated.add(config.paths.infrastructurePorts);
+  }
+  if (await updateOutboxDatabaseProvider(targetDir, config, options)) {
+    updated.add(path.join(infrastructureDir(config), "db/provider.ts"));
+  }
+  if (await updateOutboxRepositoriesReturnType(targetDir, config, options)) {
+    updated.add(drizzleRepositoriesPath(config));
+  }
+
+  return [...updated];
+}
+
+async function applyOutboxPortWiring(
+  result: MakeResult,
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<void> {
+  const updatedFiles = await updateOutboxPortWiring(targetDir, config, options);
+  for (const file of updatedFiles) {
+    if (!result.updatedFiles.includes(file)) result.updatedFiles.push(file);
+    if (!result.files.includes(file)) result.files.push(file);
+  }
+}
+
+async function updateOutboxPorts(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.ports);
+  const original = await readFile(filePath, "utf8");
+  let next = addNamedTypeImport(original, "OutboxPort", "@beignet/core/outbox");
+  if (!typeHasTopLevelProperty(next, "AppPorts", "outbox")) {
+    next = insertTypeProperty(
+      next,
+      "AppPorts",
+      "outbox: OutboxPort;",
+      `Could not find AppPorts in ${config.paths.ports}. Add outbox: OutboxPort; manually, or restore the generated ports file before running make outbox.`,
+    );
+  }
+  if (!typeHasTopLevelProperty(next, "AppTransactionPorts", "outbox")) {
+    next = insertTypeProperty(
+      next,
+      "AppTransactionPorts",
+      "outbox: OutboxPort;",
+      `Could not find AppTransactionPorts in ${config.paths.ports}. Add outbox: OutboxPort; manually, or restore the generated ports file before running make outbox.`,
+    );
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateOutboxInfrastructurePorts(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, config.paths.infrastructurePorts);
+  const original = await readFile(filePath, "utf8");
+  const next = appendDeferredPortKey(original, "outbox");
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateOutboxDatabaseProvider(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const file = path.join(infrastructureDir(config), "db/provider.ts");
+  const filePath = path.join(targetDir, file);
+  if (!(await fileExists(filePath))) return false;
+
+  const database = await detectResourceDatabase(targetDir, config);
+  const factoryName = drizzleOutboxPortFactoryName(database);
+  const original = await readFile(filePath, "utf8");
+  let next = addNamedImport(
+    original,
+    factoryName,
+    `@beignet/provider-db-drizzle/${database}`,
+  );
+  next = appendPickStringLiteralMember(next, "AppPorts", "outbox");
+
+  if (!/\bconst\s+outbox\s*=/.test(next)) {
+    const beforeOutboxConst = next;
+    next = beforeOutboxConst.replace(
+      /(\n\s*const idempotency = createDrizzle[A-Za-z]+IdempotencyPort\(dbPort\.db\);)/,
+      `$1\n\t\tconst outbox = ${factoryName}(dbPort.db);`,
+    );
+    if (next === beforeOutboxConst) {
+      throw new Error(
+        `Could not find the idempotency port in ${file}. Add const outbox = ${factoryName}(dbPort.db) manually, or restore the generated database provider before running make outbox.`,
+      );
+    }
+  }
+
+  if (!/\boutbox\s*,/.test(next)) {
+    const withOutboxPort = next.replace(
+      /(\n\s*idempotency,\n)/,
+      `$1\t\t\toutbox,\n`,
+    );
+    if (withOutboxPort === next) {
+      throw new Error(
+        `Could not find idempotency in providedPorts in ${file}. Add outbox to providedPorts manually, or restore the generated database provider before running make outbox.`,
+      );
+    }
+    next = withOutboxPort;
+  }
+
+  if (!new RegExp(`outbox:\\s*${factoryName}\\(tx\\)`).test(next)) {
+    const withTransactionOutbox = next.replace(
+      /(\n\s*idempotency: createDrizzle[A-Za-z]+IdempotencyPort\(tx\),\n)/,
+      `$1\t\t\t\t\toutbox: ${factoryName}(tx),\n`,
+    );
+    if (withTransactionOutbox === next) {
+      throw new Error(
+        `Could not find transaction idempotency wiring in ${file}. Add outbox: ${factoryName}(tx) manually, or restore the generated database provider before running make outbox.`,
+      );
+    }
+    next = withTransactionOutbox;
+  }
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+async function updateOutboxRepositoriesReturnType(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const file = drizzleRepositoriesPath(config);
+  const filePath = path.join(targetDir, file);
+  if (!(await fileExists(filePath))) return false;
+
+  const original = await readFile(filePath, "utf8");
+  const next = original.replace(
+    /Omit<AppTransactionPorts,\s*"idempotency"\s*>/g,
+    'Omit<AppTransactionPorts, "idempotency" | "outbox">',
+  );
+
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
+function drizzleOutboxPortFactoryName(database: DatabaseName): string {
+  if (database === "postgres") return "createDrizzlePostgresOutboxPort";
+  if (database === "mysql") return "createDrizzleMysqlOutboxPort";
+  return "createDrizzleSqliteOutboxPort";
+}
+
+async function applyOutboxDrainWiring(
+  result: MakeResult,
+  targetDir: string,
+  plan: OutboxDrainWiringPlan | undefined,
+  options: { dryRun: boolean },
+): Promise<void> {
+  if (!plan) return;
+
+  if (!options.dryRun) {
+    await writePlannedGeneratedFile(targetDir, plan.route);
+  }
+
+  if (plan.route.result === "created") {
+    result.createdFiles.push(plan.route.path);
+  }
+  if (plan.route.result === "updated") {
+    result.updatedFiles.push(plan.route.path);
+  }
+  if (plan.route.result === "skipped") {
+    result.skippedFiles.push(plan.route.path);
+  }
+  if (!result.files.includes(plan.route.path)) {
+    result.files.push(plan.route.path);
+  }
+
+  const cronSecretResult = await applyCronSecretWiring(
+    targetDir,
+    plan.cronSecret,
+    options,
+  );
+  result.createdFiles = uniqueStrings([
+    ...result.createdFiles,
+    ...cronSecretResult.createdFiles,
+  ]);
+  result.updatedFiles = uniqueStrings([
+    ...result.updatedFiles,
+    ...cronSecretResult.updatedFiles,
+  ]);
+  result.skippedFiles = uniqueStrings([
+    ...result.skippedFiles,
+    ...cronSecretResult.skippedFiles,
+  ]);
+  result.files = uniqueStrings([
+    ...result.files,
+    ...plan.cronSecret.files.map((file) => file.path),
+    ...plan.cronSecret.skippedFiles,
+  ]);
+}
+
 /**
  * A provider-backed app port a generator depends on.
  *
@@ -1588,6 +1986,18 @@ function paymentsPortWiring(command: string): PortProviderWiring {
   };
 }
 
+function storagePortWiring(command: string): PortProviderWiring {
+  return {
+    command,
+    portKey: "storage",
+    portType: "StoragePort",
+    portTypeModule: "@beignet/core/ports",
+    providerFactory: "createLocalStorageProvider",
+    providerModule: "@beignet/provider-storage-local",
+    dependency: "@beignet/provider-storage-local",
+  };
+}
+
 function providersFilePath(config: ResolvedBeignetConfig): string {
   return `${directoryPath(path.dirname(config.paths.server))}/providers.ts`;
 }
@@ -1770,7 +2180,16 @@ export async function makeUpload(
 
   await assertFeatureArtifactApp(targetDir, config, "upload");
 
-  return makeFeatureArtifact({
+  await wirePortProviders(
+    targetDir,
+    config,
+    [storagePortWiring("make upload")],
+    {
+      dryRun: true,
+    },
+  );
+
+  const result = await makeFeatureArtifact({
     targetDir,
     config,
     force: Boolean(options.force),
@@ -1782,6 +2201,95 @@ export async function makeUpload(
       "@beignet/core": beignetDependencyVersion,
     },
   });
+
+  await applyPortProviderWiring(
+    result,
+    targetDir,
+    config,
+    [storagePortWiring("make upload")],
+    { dryRun: Boolean(options.dryRun) },
+  );
+
+  const uploadRouteResult = await updateUploadRoute(targetDir, names, config, {
+    dryRun: Boolean(options.dryRun),
+  });
+  if (uploadRouteResult === "created")
+    result.createdFiles.push(uploadRoutePath(config));
+  if (uploadRouteResult === "updated")
+    result.updatedFiles.push(uploadRoutePath(config));
+  if (uploadRouteResult === "skipped")
+    result.skippedFiles.push(uploadRoutePath(config));
+  if (!result.files.includes(uploadRoutePath(config))) {
+    result.files.push(uploadRoutePath(config));
+  }
+
+  return result;
+}
+
+export async function makeOutbox(
+  options: MakeOutboxOptions = {},
+): Promise<MakeOutboxResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertServerRuntimeApp(targetDir, config, "outbox");
+  await updateOutboxPortWiring(targetDir, config, { dryRun: true });
+
+  const cronSecretPlan = await planCronSecretWiring(targetDir);
+  const files = outboxFiles(config);
+  const plannedFiles = await planGeneratedFiles(targetDir, files, {
+    force: Boolean(options.force),
+  });
+  const createdFiles = plannedFiles
+    .filter((file) => file.result === "created")
+    .map((file) => file.path);
+  const updatedFiles = plannedFiles
+    .filter((file) => file.result === "updated")
+    .map((file) => file.path);
+  const skippedFiles = plannedFiles
+    .filter((file) => file.result === "skipped")
+    .map((file) => file.path);
+
+  if (!options.dryRun) {
+    for (const file of plannedFiles) {
+      await writePlannedGeneratedFile(targetDir, file);
+    }
+  }
+
+  const cronSecretResult = await applyCronSecretWiring(
+    targetDir,
+    cronSecretPlan,
+    { dryRun: Boolean(options.dryRun) },
+  );
+  createdFiles.push(...cronSecretResult.createdFiles);
+  updatedFiles.push(...cronSecretResult.updatedFiles);
+  skippedFiles.push(...cronSecretResult.skippedFiles);
+  updatedFiles.push(
+    ...(await updateOutboxPortWiring(targetDir, config, {
+      dryRun: Boolean(options.dryRun),
+    })),
+  );
+
+  return {
+    schemaVersion: 1,
+    name: "outbox",
+    targetDir,
+    dryRun: Boolean(options.dryRun),
+    files: [
+      ...files.map((file) => file.path),
+      ...cronSecretPlan.files.map((file) => file.path),
+      ...cronSecretPlan.skippedFiles,
+      config.paths.ports,
+      config.paths.infrastructurePorts,
+      path.join(infrastructureDir(config), "db/provider.ts"),
+      drizzleRepositoriesPath(config),
+    ],
+    createdFiles: uniqueStrings(createdFiles),
+    updatedFiles: uniqueStrings(updatedFiles),
+    skippedFiles: uniqueStrings(skippedFiles),
+  };
 }
 
 async function makeFeatureUi(
@@ -2017,6 +2525,28 @@ async function assertFeatureUiApp(
   }
 }
 
+async function assertServerRuntimeApp(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  artifact: string,
+): Promise<void> {
+  const requiredFiles = [
+    config.paths.appContext,
+    config.paths.server,
+    config.paths.infrastructurePorts,
+  ];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make ${artifact} expects a standard Beignet app with a server runtime. Missing ${file}.`,
+      );
+    }
+  }
+}
+
 async function assertPersistenceArtifactApp(
   targetDir: string,
   names: FactoryNames | SeedNames,
@@ -2268,6 +2798,7 @@ async function makeFeatureArtifact(options: {
 }
 
 type PackageJsonLike = {
+  scripts?: Record<string, string>;
   dependencies?: Record<string, string>;
   devDependencies?: Record<string, string>;
 };
@@ -2292,6 +2823,26 @@ async function updatePackageDependencies(
   return true;
 }
 
+async function updatePackageScripts(
+  targetDir: string,
+  scripts: Record<string, string>,
+  options: { dryRun: boolean },
+): Promise<boolean> {
+  const filePath = path.join(targetDir, "package.json");
+  const original = await readFile(filePath, "utf8");
+  const packageJson = JSON.parse(original) as PackageJsonLike;
+  packageJson.scripts = packageJson.scripts ?? {};
+
+  for (const [name, command] of Object.entries(scripts)) {
+    packageJson.scripts[name] ??= command;
+  }
+
+  const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
+  if (next === original) return false;
+  if (!options.dryRun) await writeFile(filePath, next);
+  return true;
+}
+
 function beignetDependencyVersion(packageJson: PackageJsonLike): string {
   return (
     packageJson.dependencies?.["@beignet/core"] ??
@@ -3670,6 +4221,15 @@ function typeBodySource(source: string, typeName: string): string | undefined {
   return source.slice(openBrace + 1, closeBrace);
 }
 
+function typeHasTopLevelProperty(
+  source: string,
+  typeName: string,
+  propertyName: string,
+): boolean {
+  const body = typeBodySource(source, typeName);
+  return body !== undefined && hasTopLevelObjectProperty(body, propertyName);
+}
+
 function appendUnionTypeMember(
   source: string,
   typeName: string,
@@ -3976,6 +4536,45 @@ function addNamedTypeImport(
   )}`;
 }
 
+function addNamedImport(
+  source: string,
+  name: string,
+  moduleName: string,
+): string {
+  const escapedModule = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const importPattern = new RegExp(
+    `import \\{([^}]*)\\} from "${escapedModule}";`,
+  );
+  const match = importPattern.exec(source);
+  if (!match) {
+    return insertAfterImports(
+      source,
+      `import { ${name} } from "${moduleName}";`,
+    );
+  }
+
+  const names = match[1]
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  if (names.includes(name)) return source;
+
+  const insertIndex = names.findIndex(
+    (existing) => existing.localeCompare(name) > 0,
+  );
+  if (insertIndex === -1) names.push(name);
+  else names.splice(insertIndex, 0, name);
+
+  const indent = match[1].match(/\n([\t ]+)/)?.[1] ?? "\t";
+  const replacement = match[1].includes("\n")
+    ? `import {\n${indent}${names.join(`,\n${indent}`)},\n} from "${moduleName}";`
+    : `import { ${names.join(", ")} } from "${moduleName}";`;
+
+  return `${source.slice(0, match.index)}${replacement}${source.slice(
+    match.index + match[0].length,
+  )}`;
+}
+
 function topLevelBoundObjectRange(
   source: string,
   openBrace: number,
@@ -4454,6 +5053,10 @@ function seedNames(input: string): SeedNames {
   };
 }
 
+function defaultFactoryNamesForSeed(names: SeedNames): FactoryNames {
+  return factoryNames(`${names.feature.kebab}/${names.featureSingularKebab}`);
+}
+
 function notificationNames(input: string): NotificationNames {
   const names = featureArtifactNames(input, "Notification");
   const notificationExportName = `${names.featureSingularPascal}${names.artifact.pascal}Notification`;
@@ -5065,6 +5668,19 @@ function uploadFiles(
   ];
 }
 
+function outboxFiles(config: ResolvedBeignetConfig): GeneratedFile[] {
+  return [
+    {
+      path: config.paths.outbox,
+      content: outboxRegistryFile(config),
+    },
+    {
+      path: outboxDrainRoutePath(config),
+      content: outboxDrainRouteFile(config),
+    },
+  ];
+}
+
 function portFilePath(names: PortNames, config: ResolvedBeignetConfig): string {
   return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
 }
@@ -5470,6 +6086,24 @@ function uploadFilePath(
   );
 }
 
+function seedEntrypointPath(config: ResolvedBeignetConfig): string {
+  return path.join(infrastructureDir(config), "db", "seed.ts");
+}
+
+function uploadRoutePath(config: ResolvedBeignetConfig): string {
+  return path.join(
+    config.paths.routes,
+    "uploads",
+    "[uploadName]",
+    "[action]",
+    "route.ts",
+  );
+}
+
+function outboxDrainRoutePath(config: ResolvedBeignetConfig): string {
+  return path.join(config.paths.routes, "cron", "outbox", "drain", "route.ts");
+}
+
 function scheduleRouteFilePath(
   names: ScheduleNames,
   config: ResolvedBeignetConfig,
@@ -5909,13 +6543,98 @@ export async function stopScheduleContext(): Promise<void> {
   return "updated";
 }
 
+async function updateSeedEntrypoint(
+  targetDir: string,
+  names: SeedNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult> {
+  const file = seedEntrypointPath(config);
+  const destination = path.join(targetDir, file);
+  const existing = await readOptionalFile(destination);
+  const registryName = `${names.featureSingularCamel}Seeds`;
+  const importLine = `import { ${registryName} } from "${aliasModule(
+    path.join(featureArtifactDir(names, "seeds", config), "index.ts"),
+  )}";`;
+  const registryEntry = `...${registryName}`;
+
+  if (existing === undefined) {
+    const content = seedEntrypointFile(names, config);
+    if (!options.dryRun) {
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, content);
+    }
+    return "created";
+  }
+
+  let next = existing;
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  const registry = arrayInitializerInfo(next, "seeds");
+  if (!registry) {
+    next = `${next.trimEnd()}\n\nconst seeds = [${registryEntry}] as const;\n`;
+  } else if (!identifiersFromArrayExpression(registry.text).has(registryName)) {
+    const nextArray = appendToArrayExpression(registry.text, [registryEntry]);
+    next = `${next.slice(0, registry.start)}${nextArray}${next.slice(
+      registry.end,
+    )}`;
+  }
+
+  if (next === existing) return "skipped";
+  if (!options.dryRun) await writeFile(destination, next);
+  return "updated";
+}
+
+async function updateUploadRoute(
+  targetDir: string,
+  names: UploadNames,
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult> {
+  const file = uploadRoutePath(config);
+  const destination = path.join(targetDir, file);
+  const existing = await readOptionalFile(destination);
+  const registryName = `${names.featureSingularCamel}Uploads`;
+  const registryKey = names.featureSingularCamel;
+  const importLine = `import { ${registryName} } from "${aliasModule(
+    path.join(featureArtifactDir(names, "uploads", config), "index.ts"),
+  )}";`;
+
+  if (existing === undefined) {
+    const content = uploadRouteFile(names, config);
+    if (!options.dryRun) {
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, content);
+    }
+    return "created";
+  }
+
+  let next = existing;
+  if (!next.includes(importLine)) {
+    next = insertAfterImports(next, importLine);
+  }
+
+  const registry = defineUploadsInitializerInfo(next, "uploadRegistry");
+  if (!registry) {
+    return "skipped";
+  }
+  if (!new RegExp(`\\b${registryKey}\\s*:`).test(registry.text)) {
+    next = `${next.slice(0, registry.end)}\t${registryKey}: ${registryName},\n${next.slice(
+      registry.end,
+    )}`;
+  }
+
+  if (next === existing) return "skipped";
+  if (!options.dryRun) await writeFile(destination, next);
+  return "updated";
+}
+
 /**
  * Append a feature event or job registry to `server/outbox.ts`.
- *
- * The outbox registry is opt-in, so this never creates the file; it returns
- * `undefined` when the app has no outbox module. It also bails to "skipped"
- * instead of writing when the `defineOutboxRegistry({...})` anchor is missing
- * or the matching array is not editable.
+ * Creates the registry when missing so event/job generators produce a complete
+ * drainable path instead of leaving durable delivery as manual wiring.
  */
 async function updateOutboxRegistry(
   targetDir: string,
@@ -5923,10 +6642,17 @@ async function updateOutboxRegistry(
   kind: "events" | "jobs",
   config: ResolvedBeignetConfig,
   options: { dryRun: boolean },
-): Promise<WriteGeneratedFileResult | undefined> {
+): Promise<WriteGeneratedFileResult> {
   const destination = path.join(targetDir, config.paths.outbox);
   const existing = await readOptionalFile(destination);
-  if (existing === undefined) return undefined;
+  if (existing === undefined) {
+    const content = outboxRegistryFile(config, { names, kind });
+    if (!options.dryRun) {
+      await mkdir(path.dirname(destination), { recursive: true });
+      await writeFile(destination, content);
+    }
+    return "created";
+  }
 
   const featureIndexPath = path.join(
     featureArtifactDir(names, kind, config),
@@ -5976,8 +6702,9 @@ async function applyOutboxRegistryUpdate(
     config,
     options,
   );
-  if (registryResult === undefined) return;
 
+  if (registryResult === "created")
+    result.createdFiles.push(config.paths.outbox);
   if (registryResult === "updated")
     result.updatedFiles.push(config.paths.outbox);
   if (registryResult === "skipped")
@@ -7488,6 +8215,137 @@ export const ${names.uploadExportName} = defineUpload<
 `;
 }
 
+function seedEntrypointFile(
+  names: SeedNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const registryName = `${names.featureSingularCamel}Seeds`;
+
+  return `import { createServiceActor } from "@beignet/core/ports";
+import { runSeeds } from "@beignet/core/testing";
+import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "seeds", config), "index.ts"))}";
+import { server } from "${aliasModule(config.paths.server)}";
+
+const seeds = [...${registryName}] as const;
+
+const ctx = await server.createServiceContext({
+\tactor: createServiceActor("beignet-seed"),
+});
+
+try {
+\tawait runSeeds({ ctx, seeds });
+} finally {
+\tawait server.stop();
+}
+`;
+}
+
+function uploadRouteFile(
+  names: UploadNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const registryName = `${names.featureSingularCamel}Uploads`;
+
+  return `import {
+\tcreateUploadRouter,
+\tdefineUploads,
+\tuploadsFromRegistry,
+} from "@beignet/core/uploads";
+import { createUploadRoute } from "@beignet/next";
+import { ${registryName} } from "${aliasModule(path.join(featureArtifactDir(names, "uploads", config), "index.ts"))}";
+import { server } from "${aliasModule(config.paths.server)}";
+
+const uploadRegistry = defineUploads({
+\t${names.featureSingularCamel}: ${registryName},
+});
+
+const uploadRouter = createUploadRouter({
+\tuploads: uploadsFromRegistry(uploadRegistry),
+\tctx: () => server.createContextFromNext(),
+\tstorage: server.ports.storage,
+});
+
+export const { POST } = createUploadRoute(uploadRouter);
+`;
+}
+
+function outboxRegistryFile(
+  config: ResolvedBeignetConfig,
+  registration?: {
+    names: EventNames | JobNames;
+    kind: "events" | "jobs";
+  },
+): string {
+  const featureRegistry = registration
+    ? outboxFeatureRegistry(registration.names, registration.kind, config)
+    : undefined;
+  const eventEntry =
+    featureRegistry?.kind === "events" ? `...${featureRegistry.name}` : "";
+  const jobEntry =
+    featureRegistry?.kind === "jobs" ? `...${featureRegistry.name}` : "";
+  const featureImport = featureRegistry
+    ? `${featureRegistry.importLine}\n`
+    : "";
+
+  return `import { defineOutboxRegistry } from "@beignet/core/outbox";
+import { createServiceActor } from "@beignet/core/ports";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+${featureImport}import { server } from "${relativeModule(config.paths.outbox, config.paths.server)}";
+
+export const outboxRegistry = defineOutboxRegistry({
+\tevents: [${eventEntry}],
+\tjobs: [${jobEntry}],
+});
+
+export async function createOutboxDrainContext(): Promise<AppContext> {
+\treturn server.createServiceContext({
+\t\tactor: createServiceActor("beignet-outbox"),
+\t});
+}
+
+export async function stopOutboxDrainContext(): Promise<void> {
+\tawait server.stop();
+}
+`;
+}
+
+function outboxDrainRouteFile(config: ResolvedBeignetConfig): string {
+  return `import { createOutboxDrainRoute } from "@beignet/next";
+import { env } from "@/lib/env";
+import { server } from "${aliasModule(config.paths.server)}";
+import { outboxRegistry } from "${aliasModule(config.paths.outbox)}";
+
+export const runtime = "nodejs";
+
+export const { GET, POST } = createOutboxDrainRoute({
+\tserver,
+\tregistry: outboxRegistry,
+\tsecret: env.CRON_SECRET,
+\tbatchSize: 100,
+});
+`;
+}
+
+function outboxFeatureRegistry(
+  names: EventNames | JobNames,
+  kind: "events" | "jobs",
+  config: ResolvedBeignetConfig,
+): { kind: "events" | "jobs"; name: string; importLine: string } {
+  const featureIndexPath = path.join(
+    featureArtifactDir(names, kind, config),
+    "index.ts",
+  );
+  const name = `${names.featureSingularCamel}${
+    kind === "events" ? "Events" : "Jobs"
+  }`;
+
+  return {
+    kind,
+    name,
+    importLine: `import { ${name} } from "${aliasModule(featureIndexPath)}";`,
+  };
+}
+
 function billingSchemasFile(): string {
   return `import { z } from "zod";