@beignet/cli 0.0.6 → 0.0.8

package/src/make.ts

@@ -10,6 +10,15 @@ import {
   type ResolvedBeignetConfig,
   resolveConfig,
 } from "./config.js";
+import {
+  appendToArrayExpression,
+  appendToNamedArray,
+  appendToOutboxRegistryArray,
+  arrayInitializerInfo,
+  identifiersFromArrayExpression,
+  insertAfterImports,
+  matchingDelimiterIndex,
+} from "./registry-edits.js";
 
 type MakeResourceOptions = {
   name: string;
@@ -450,6 +459,21 @@ async function makeResourceSlice(
       generationOptions,
     },
   );
+  // Generated event-publishing use cases depend on ctx.ports.eventBus, so
+  // --events also wires the port, a deferred key, the in-memory dev provider,
+  // and the provider dependency. Plan the wiring before writing any files so
+  // an anchor miss aborts the generator without leaving partial output.
+  const eventBusWirings = generationOptions.events
+    ? [eventBusPortWiring("make resource --events")]
+    : [];
+  const plannedEventBusUpdates =
+    eventBusWirings.length > 0
+      ? (
+          await wirePortProviders(targetDir, config, eventBusWirings, {
+            dryRun: true,
+          })
+        ).updatedFiles
+      : [];
   const createdFiles = plannedFiles
     .filter((file) => file.result === "created")
     .map((file) => file.path);
@@ -461,7 +485,7 @@ async function makeResourceSlice(
     .map((file) => file.path);
 
   if (options.dryRun) {
-    updatedFiles.push(...plannedWiringUpdates);
+    updatedFiles.push(...plannedWiringUpdates, ...plannedEventBusUpdates);
   } else {
     for (const file of plannedFiles) {
       await writePlannedGeneratedFile(targetDir, file);
@@ -475,6 +499,16 @@ async function makeResourceSlice(
         generationOptions,
       })),
     );
+
+    if (eventBusWirings.length > 0) {
+      updatedFiles.push(
+        ...(
+          await wirePortProviders(targetDir, config, eventBusWirings, {
+            dryRun: false,
+          })
+        ).updatedFiles,
+      );
+    }
   }
 
   return {
@@ -484,7 +518,7 @@ async function makeResourceSlice(
     dryRun: Boolean(options.dryRun),
     files: generatedFiles.map((file) => file.path),
     createdFiles,
-    updatedFiles,
+    updatedFiles: uniqueStrings(updatedFiles),
     skippedFiles,
   };
 }
@@ -881,7 +915,16 @@ export async function makeEvent(
 
   await assertFeatureArtifactApp(targetDir, config, "event");
 
-  return makeFeatureArtifact({
+  // 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
+  // the wiring before writing any files so an anchor miss aborts the
+  // generator without leaving partial output.
+  const eventBusWirings = [eventBusPortWiring("make event")];
+  await wirePortProviders(targetDir, config, eventBusWirings, {
+    dryRun: true,
+  });
+
+  const result = await makeFeatureArtifact({
     targetDir,
     config,
     force: Boolean(options.force),
@@ -893,6 +936,16 @@ export async function makeEvent(
       "@beignet/core": beignetDependencyVersion,
     },
   });
+
+  await applyOutboxRegistryUpdate(result, targetDir, names, "events", config, {
+    dryRun: Boolean(options.dryRun),
+  });
+
+  await applyPortProviderWiring(result, targetDir, config, eventBusWirings, {
+    dryRun: Boolean(options.dryRun),
+  });
+
+  return result;
 }
 
 export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
@@ -904,7 +957,7 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
 
   await assertFeatureArtifactApp(targetDir, config, "job");
 
-  return makeFeatureArtifact({
+  const result = await makeFeatureArtifact({
     targetDir,
     config,
     force: Boolean(options.force),
@@ -919,6 +972,12 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
       "@beignet/core": beignetDependencyVersion,
     },
   });
+
+  await applyOutboxRegistryUpdate(result, targetDir, names, "jobs", config, {
+    dryRun: Boolean(options.dryRun),
+  });
+
+  return result;
 }
 
 export async function makeTask(
@@ -1025,7 +1084,19 @@ export async function makeNotification(
 
   await assertFeatureArtifactApp(targetDir, config, "notification");
 
-  return makeFeatureArtifact({
+  // The generated mail channel sends through ctx.ports.mailer and sending
+  // notifications uses ctx.ports.notifications, so the generator wires both
+  // ports with dev-default providers. Each port is wired independently and
+  // skipped when the app already has it, for example when the resend
+  // integration contributed the mailer. Plan the wiring before writing any
+  // files so an anchor miss aborts the generator without leaving partial
+  // output.
+  const notificationWirings = notificationPortWirings("make notification");
+  await wirePortProviders(targetDir, config, notificationWirings, {
+    dryRun: true,
+  });
+
+  const result = await makeFeatureArtifact({
     targetDir,
     config,
     force: Boolean(options.force),
@@ -1044,6 +1115,16 @@ export async function makeNotification(
       "@beignet/core": beignetDependencyVersion,
     },
   });
+
+  await applyPortProviderWiring(
+    result,
+    targetDir,
+    config,
+    notificationWirings,
+    { dryRun: Boolean(options.dryRun) },
+  );
+
+  return result;
 }
 
 export async function makeListener(
@@ -1265,6 +1346,236 @@ async function applyCronSecretWiring(
   };
 }
 
+/**
+ * A provider-backed app port a generator depends on.
+ *
+ * Generated code that publishes events or sends notifications needs the
+ * matching port in `AppPorts`, the key deferred in `infra/app-ports.ts`, and a
+ * dev-default provider registered in `server/providers.ts`. Wiring is
+ * generation-time by design: the starter stays lean and each generator wires
+ * its own dependencies.
+ */
+type PortProviderWiring = {
+  /** Generator command named in manual instructions, e.g. "make event". */
+  command: string;
+  /** AppPorts key the provider contributes. */
+  portKey: string;
+  /** Port interface name added to the ports file type imports. */
+  portType: string;
+  /** Module the port interface is imported from. */
+  portTypeModule: string;
+  /** Provider factory registered in the providers array. */
+  providerFactory: string;
+  /** Module the provider factory is imported from. */
+  providerModule: string;
+  /** package.json dependency for providers that live outside @beignet/core. */
+  dependency?: string;
+};
+
+function eventBusPortWiring(command: string): PortProviderWiring {
+  return {
+    command,
+    portKey: "eventBus",
+    portType: "EventBusPort",
+    portTypeModule: "@beignet/core/ports",
+    providerFactory: "createInMemoryEventBusProvider",
+    providerModule: "@beignet/provider-event-bus-memory",
+    dependency: "@beignet/provider-event-bus-memory",
+  };
+}
+
+function notificationPortWirings(command: string): PortProviderWiring[] {
+  return [
+    {
+      command,
+      portKey: "mailer",
+      portType: "MailerPort",
+      portTypeModule: "@beignet/core/mail",
+      providerFactory: "createMemoryMailerProvider",
+      providerModule: "@beignet/core/mail",
+    },
+    {
+      command,
+      portKey: "notifications",
+      portType: "NotificationPort",
+      portTypeModule: "@beignet/core/notifications",
+      providerFactory: "createInlineNotificationsProvider",
+      providerModule: "@beignet/core/notifications",
+    },
+  ];
+}
+
+function providersFilePath(config: ResolvedBeignetConfig): string {
+  return `${directoryPath(path.dirname(config.paths.server))}/providers.ts`;
+}
+
+/**
+ * Wire provider-backed app ports a generator depends on.
+ *
+ * Each wiring is independent and skipped silently when its port key already
+ * appears in the ports file, so apps that wired their own adapter (or scaffolds
+ * whose integrations already contribute the port) are left untouched. All
+ * anchors are computed before any file is written; an anchor miss aborts with a
+ * copy-pasteable manual instruction so the generator never leaves partial
+ * wiring behind. Callers validate anchors with `dryRun: true` before writing
+ * artifact files.
+ */
+async function wirePortProviders(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  wirings: readonly PortProviderWiring[],
+  options: { dryRun: boolean },
+): Promise<{ updatedFiles: string[] }> {
+  const portsFile = config.paths.ports;
+  const infrastructureFile = config.paths.infrastructurePorts;
+  const providersFile = providersFilePath(config);
+  const manualFor = (wiring: PortProviderWiring) =>
+    `Wire the ${wiring.portKey} port manually: add ${wiring.portKey}: ${wiring.portType}; to AppPorts in ${portsFile}, defer "${wiring.portKey}" in ${infrastructureFile}, and register ${wiring.providerFactory}() from ${wiring.providerModule} in ${providersFile}.`;
+
+  const portsOriginal = await readOptionalFile(path.join(targetDir, portsFile));
+  if (portsOriginal === undefined) {
+    if (wirings.length === 0) return { updatedFiles: [] };
+    throw new Error(
+      `Could not find the generated ports file ${portsFile}. ${manualFor(wirings[0])}`,
+    );
+  }
+
+  // A port key that already appears in the ports file means the app wired its
+  // own adapter or an integration already contributes the port.
+  const active = wirings.filter(
+    (wiring) => !new RegExp(`\\b${wiring.portKey}\\b`).test(portsOriginal),
+  );
+  if (active.length === 0) return { updatedFiles: [] };
+
+  let portsNext = portsOriginal;
+  for (const wiring of active) {
+    portsNext = addNamedTypeImport(
+      portsNext,
+      wiring.portType,
+      wiring.portTypeModule,
+    );
+    portsNext = insertTypeProperty(
+      portsNext,
+      "AppPorts",
+      `${wiring.portKey}: ${wiring.portType};`,
+      `Could not find AppPorts in ${portsFile}. ${manualFor(wiring)} Or restore the generated ports file before running beignet ${wiring.command}.`,
+    );
+  }
+
+  const infrastructureOriginal = await readOptionalFile(
+    path.join(targetDir, infrastructureFile),
+  );
+  if (infrastructureOriginal === undefined) {
+    throw new Error(
+      `Could not find the generated infrastructure ports file ${infrastructureFile}. ${manualFor(active[0])}`,
+    );
+  }
+
+  let infrastructureNext = infrastructureOriginal;
+  for (const wiring of active) {
+    const appended = appendDeferredPortKey(infrastructureNext, wiring.portKey);
+    if (
+      appended === infrastructureNext &&
+      !new RegExp(`["']${wiring.portKey}["']`).test(infrastructureNext)
+    ) {
+      throw new Error(
+        `Could not find the deferred port list in ${infrastructureFile}. ${manualFor(wiring)} Or restore the generated infrastructure ports file before running beignet ${wiring.command}.`,
+      );
+    }
+    infrastructureNext = appended;
+  }
+
+  const providersOriginal = await readOptionalFile(
+    path.join(targetDir, providersFile),
+  );
+  if (providersOriginal === undefined) {
+    throw new Error(
+      `Could not find the generated providers file ${providersFile}. ${manualFor(active[0])}`,
+    );
+  }
+
+  let providersNext = providersOriginal;
+  for (const wiring of active) {
+    if (new RegExp(`\\b${wiring.providerFactory}\\b`).test(providersNext)) {
+      continue;
+    }
+    const appended = appendToNamedArray(
+      providersNext,
+      "providers",
+      `${wiring.providerFactory}()`,
+      `import { ${wiring.providerFactory} } from "${wiring.providerModule}";`,
+    );
+    if (appended.kind === "missing") {
+      throw new Error(
+        `Could not find the exported providers array in ${providersFile}. ${manualFor(wiring)} Or restore the generated providers file before running beignet ${wiring.command}.`,
+      );
+    }
+    if (appended.kind === "updated") providersNext = appended.source;
+  }
+
+  const dependencies = active.filter(
+    (wiring): wiring is PortProviderWiring & { dependency: string } =>
+      wiring.dependency !== undefined,
+  );
+  let packageJsonNext: string | undefined;
+  if (dependencies.length > 0) {
+    const packageJsonOriginal = await readFile(
+      path.join(targetDir, "package.json"),
+      "utf8",
+    );
+    const packageJson = JSON.parse(packageJsonOriginal) as PackageJsonLike;
+    packageJson.dependencies = packageJson.dependencies ?? {};
+    for (const wiring of dependencies) {
+      packageJson.dependencies[wiring.dependency] ??=
+        beignetDependencyVersion(packageJson);
+    }
+    const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
+    if (next !== packageJsonOriginal) packageJsonNext = next;
+  }
+
+  const plannedFiles: Array<{ path: string; content: string }> = [];
+  if (portsNext !== portsOriginal) {
+    plannedFiles.push({ path: portsFile, content: portsNext });
+  }
+  if (infrastructureNext !== infrastructureOriginal) {
+    plannedFiles.push({
+      path: infrastructureFile,
+      content: infrastructureNext,
+    });
+  }
+  if (providersNext !== providersOriginal) {
+    plannedFiles.push({ path: providersFile, content: providersNext });
+  }
+  if (packageJsonNext !== undefined) {
+    plannedFiles.push({ path: "package.json", content: packageJsonNext });
+  }
+
+  if (!options.dryRun) {
+    for (const file of plannedFiles) {
+      await writeFile(path.join(targetDir, file.path), file.content);
+    }
+  }
+
+  return { updatedFiles: plannedFiles.map((file) => file.path) };
+}
+
+/**
+ * Record port provider wiring updates on a make result.
+ */
+async function applyPortProviderWiring(
+  result: { files: string[]; updatedFiles: string[] },
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+  wirings: readonly PortProviderWiring[],
+  options: { dryRun: boolean },
+): Promise<void> {
+  const wired = await wirePortProviders(targetDir, config, wirings, options);
+  for (const file of wired.updatedFiles) {
+    if (!result.updatedFiles.includes(file)) result.updatedFiles.push(file);
+    if (!result.files.includes(file)) result.files.push(file);
+  }
+}
+
 export async function makeUpload(
   options: MakeUploadOptions,
 ): Promise<MakeUploadResult> {
@@ -2720,65 +3031,6 @@ function trimmedSlice(
   };
 }
 
-function identifiersFromArrayExpression(expression: string): Set<string> {
-  const withoutBrackets = expression.replace(/^\[/, "").replace(/\]$/, "");
-
-  return new Set(
-    Array.from(
-      withoutBrackets.matchAll(/\b[A-Za-z_$][\w$]*\b/g),
-      ([name]) => name,
-    ),
-  );
-}
-
-function appendToArrayExpression(expression: string, names: string[]): string {
-  const closingBracket = /\]\s*$/.exec(expression);
-  if (!closingBracket) return expression;
-
-  const beforeClosingBracket = expression.slice(0, closingBracket.index);
-  const closingBracketText = expression.slice(closingBracket.index);
-  const inner = beforeClosingBracket.replace(/^\[/, "");
-  if (!inner.trim()) return `[${names.join(", ")}]`;
-
-  if (!expression.includes("\n")) {
-    const separator = /,\s*$/.test(inner) ? " " : ", ";
-    return `${beforeClosingBracket}${separator}${names.join(", ")}${closingBracketText}`;
-  }
-
-  const itemIndent =
-    inner
-      .split("\n")
-      .find((line) => line.trim())
-      ?.match(/^[\t ]*/)?.[0] ?? "\t";
-  const closingIndent = inner.match(/\n([\t ]*)$/)?.[1] ?? "";
-  const trimmedBeforeClosingBracket = beforeClosingBracket.replace(/\s*$/, "");
-  const appendedNames = names.join(`,\n${itemIndent}`);
-
-  if (/,\s*$/.test(inner)) {
-    return `${trimmedBeforeClosingBracket}\n${itemIndent}${appendedNames},\n${closingIndent}${closingBracketText}`;
-  }
-
-  return `${trimmedBeforeClosingBracket},\n${itemIndent}${appendedNames}${closingBracketText}`;
-}
-
-function insertAfterImports(source: string, line: string): string {
-  const lines = source.split("\n");
-  let lastImportIndex = -1;
-
-  for (let index = 0; index < lines.length; index++) {
-    if (lines[index].startsWith("import ")) {
-      lastImportIndex = index;
-    }
-  }
-
-  if (lastImportIndex === -1) {
-    return `${line}\n${source}`;
-  }
-
-  lines.splice(lastImportIndex + 1, 0, line);
-  return lines.join("\n");
-}
-
 function replaceRequired(
   source: string,
   searchValue: RegExp,
@@ -3059,6 +3311,50 @@ function appendDeferredPortKey(source: string, portKey: string): string {
   )}`;
 }
 
+/**
+ * Add a name to an `import type { ... } from "<module>";` statement, creating
+ * the import when the module is not imported yet. Names are inserted in sorted
+ * position and single-line versus multiline formatting is preserved.
+ */
+function addNamedTypeImport(
+  source: string,
+  name: string,
+  moduleName: string,
+): string {
+  const escapedModule = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const importPattern = new RegExp(
+    `import type \\{([^}]*)\\} from "${escapedModule}";`,
+  );
+  const match = importPattern.exec(source);
+  if (!match) {
+    return insertAfterImports(
+      source,
+      `import type { ${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 type {\n${indent}${names.join(`,\n${indent}`)},\n} from "${moduleName}";`
+    : `import type { ${names.join(", ")} } from "${moduleName}";`;
+
+  return `${source.slice(0, match.index)}${replacement}${source.slice(
+    match.index + match[0].length,
+  )}`;
+}
+
 function topLevelBoundObjectRange(
   source: string,
   openBrace: number,
@@ -3280,48 +3576,6 @@ function matchingBraceIndex(source: string, openBrace: number): number {
   return matchingDelimiterIndex(source, openBrace, "{", "}");
 }
 
-function matchingDelimiterIndex(
-  source: string,
-  openIndex: number,
-  open: string,
-  close: string,
-): number {
-  let depth = 0;
-  let inString: string | undefined;
-  let escaped = false;
-
-  for (let index = openIndex; index < source.length; index++) {
-    const char = source[index];
-    if (inString) {
-      if (escaped) {
-        escaped = false;
-      } else if (char === "\\") {
-        escaped = true;
-      } else if (char === inString) {
-        inString = undefined;
-      }
-      continue;
-    }
-
-    if (char === '"' || char === "'" || char === "`") {
-      inString = char;
-      continue;
-    }
-
-    if (char === open) {
-      depth++;
-      continue;
-    }
-
-    if (char === close) {
-      depth--;
-      if (depth === 0) return index;
-    }
-  }
-
-  return -1;
-}
-
 function replaceTransactionPortsRequired(
   source: string,
   entry: string,
@@ -4932,24 +5186,82 @@ export async function stopScheduleContext(): Promise<void> {
   return "updated";
 }
 
-function arrayInitializerInfo(
-  source: string,
-  constName: string,
-): { text: string; start: number; end: number } | undefined {
-  const match = new RegExp(`\\bconst\\s+${constName}\\s*=`).exec(source);
-  if (!match) return undefined;
+/**
+ * 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.
+ */
+async function updateOutboxRegistry(
+  targetDir: string,
+  names: EventNames | JobNames,
+  kind: "events" | "jobs",
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<WriteGeneratedFileResult | undefined> {
+  const destination = path.join(targetDir, config.paths.outbox);
+  const existing = await readOptionalFile(destination);
+  if (existing === undefined) return undefined;
 
-  const openBracket = source.indexOf("[", match.index);
-  if (openBracket === -1) return undefined;
+  const featureIndexPath = path.join(
+    featureArtifactDir(names, kind, config),
+    "index.ts",
+  );
+  const registryName = `${names.featureSingularCamel}${
+    kind === "events" ? "Events" : "Jobs"
+  }`;
+  const importLine = `import { ${registryName} } from "${aliasModule(featureIndexPath)}";`;
+  const appended = appendToOutboxRegistryArray(
+    existing,
+    kind,
+    `...${registryName}`,
+    importLine,
+  );
 
-  const closeBracket = matchingDelimiterIndex(source, openBracket, "[", "]");
-  if (closeBracket === -1) return undefined;
+  if (appended.kind === "missing" || appended.kind === "unchanged") {
+    return "skipped";
+  }
 
-  return {
-    text: source.slice(openBracket, closeBracket + 1),
-    start: openBracket,
-    end: closeBracket + 1,
-  };
+  if (!options.dryRun) await writeFile(destination, appended.source);
+  return "updated";
+}
+
+/**
+ * Record an outbox registry update on a make result using the same
+ * bookkeeping as the task and schedule registries. No-op when the app has no
+ * outbox module.
+ */
+async function applyOutboxRegistryUpdate(
+  result: {
+    files: string[];
+    createdFiles: string[];
+    updatedFiles: string[];
+    skippedFiles: string[];
+  },
+  targetDir: string,
+  names: EventNames | JobNames,
+  kind: "events" | "jobs",
+  config: ResolvedBeignetConfig,
+  options: { dryRun: boolean },
+): Promise<void> {
+  const registryResult = await updateOutboxRegistry(
+    targetDir,
+    names,
+    kind,
+    config,
+    options,
+  );
+  if (registryResult === undefined) return;
+
+  if (registryResult === "updated")
+    result.updatedFiles.push(config.paths.outbox);
+  if (registryResult === "skipped")
+    result.skippedFiles.push(config.paths.outbox);
+  if (!result.files.includes(config.paths.outbox)) {
+    result.files.push(config.paths.outbox);
+  }
 }
 
 function defineUploadsInitializerInfo(