@beignet/cli 0.0.1 → 0.0.3

package/src/index.ts

@@ -14,6 +14,7 @@ import {
 } from "@stricli/core";
 import type { CreateOptions } from "./create.js";
 import { createProject } from "./create.js";
+import { type DatabaseCommand, runDatabaseCommand } from "./db.js";
 import {
   applyDoctorFixes,
   formatDoctor,
@@ -25,15 +26,24 @@ import {
   makeAdapter,
   makeContract,
   makeEvent,
+  makeFactory,
+  makeFeature,
+  makeFeatureAddonChoices,
   makeJob,
   makeListener,
+  makeNotification,
   makePolicy,
   makePort,
   makeResource,
   makeSchedule,
+  makeSeed,
   makeTest,
+  makeUpload,
   makeUseCase,
 } from "./make.js";
+
+export type { MakeFeatureAddon } from "./make.js";
+
 import {
   type FeatureName,
   featureChoices,
@@ -58,14 +68,21 @@ export {
   makeAdapter,
   makeContract,
   makeEvent,
+  makeFactory,
+  makeFeature,
+  makeFeatureAddonChoices,
   makeJob,
   makeListener,
+  makeNotification,
   makePolicy,
   makePort,
   makeResource,
   makeSchedule,
+  makeSeed,
   makeTest,
+  makeUpload,
   makeUseCase,
+  runDatabaseCommand,
 };
 
 type CliContext = CommandContext & {
@@ -89,6 +106,10 @@ type MakeFlags = {
   json?: boolean;
 };
 
+type MakeFeatureFlags = MakeFlags & {
+  with?: readonly (typeof makeFeatureAddonChoices)[number][];
+};
+
 type MakeListenerFlags = MakeFlags & {
   event?: string;
 };
@@ -103,6 +124,11 @@ type JsonFlags = {
   json?: boolean;
 };
 
+type DbFlags = {
+  json?: boolean;
+  dryRun?: boolean;
+};
+
 type DoctorFlags = {
   json?: boolean;
   strict?: boolean;
@@ -158,6 +184,11 @@ const jsonFlagParameters = {
   json: jsonFlag,
 } satisfies FlagParametersForType<JsonFlags, CliContext>;
 
+const dbFlagParameters = {
+  json: jsonFlag,
+  dryRun: dryRunFlag,
+} satisfies FlagParametersForType<DbFlags, CliContext>;
+
 const namePositional = {
   kind: "tuple",
   parameters: [
@@ -337,6 +368,46 @@ const lintCommand = buildCommand<JsonFlags, [], CliContext>({
   },
 });
 
+function databaseCommand(command: DatabaseCommand) {
+  return buildCommand<DbFlags, [], CliContext>({
+    docs: {
+      brief: `Run the app's db:${command} script.`,
+    },
+    parameters: {
+      flags: dbFlagParameters,
+    },
+    async func(flags) {
+      const result = await runDatabaseCommand({
+        command,
+        captureOutput: Boolean(flags.json),
+        dryRun: Boolean(flags.dryRun),
+      });
+
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : databaseCommandNextSteps(result),
+      );
+      if (result.exitCode !== 0) {
+        this.process.exitCode = result.exitCode;
+      }
+    },
+  });
+}
+
+const dbRoutes = buildRouteMap({
+  docs: {
+    brief: "Run Beignet database lifecycle commands.",
+  },
+  routes: {
+    generate: databaseCommand("generate"),
+    migrate: databaseCommand("migrate"),
+    reset: databaseCommand("reset"),
+    seed: databaseCommand("seed"),
+  },
+});
+
 const makeResourceCommand = buildCommand<MakeFlags, [string], CliContext>({
   docs: {
     brief: "Generate a feature resource.",
@@ -360,6 +431,42 @@ const makeResourceCommand = buildCommand<MakeFlags, [string], CliContext>({
   },
 });
 
+const makeFeatureCommand = buildCommand<MakeFeatureFlags, [string], CliContext>(
+  {
+    docs: {
+      brief: "Generate a contract-first feature slice.",
+    },
+    parameters: {
+      flags: {
+        ...makeFlagParameters,
+        with: {
+          kind: "enum",
+          values: makeFeatureAddonChoices,
+          optional: true,
+          variadic: ",",
+          brief:
+            "Add feature-owned artifacts. Supports policy, event/events, job/jobs, and upload/uploads.",
+        },
+      } satisfies FlagParametersForType<MakeFeatureFlags, CliContext>,
+      positional: namePositional,
+    },
+    async func(flags, name) {
+      const result = await makeFeature({
+        name,
+        with: flags.with,
+        force: Boolean(flags.force),
+        dryRun: Boolean(flags.dryRun),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : makeFeatureNextSteps(result),
+      );
+    },
+  },
+);
+
 const makeContractCommand = buildCommand<MakeFlags, [string], CliContext>({
   docs: {
     brief: "Generate a contract group.",
@@ -536,6 +643,73 @@ const makeJobCommand = buildCommand<MakeFlags, [string], CliContext>({
   },
 });
 
+const makeFactoryCommand = buildCommand<MakeFlags, [string], CliContext>({
+  docs: {
+    brief: "Generate a feature test data factory.",
+  },
+  parameters: {
+    flags: makeFlagParameters,
+    positional: namePositional,
+  },
+  async func(flags, name) {
+    const result = await makeFactory({
+      name,
+      force: Boolean(flags.force),
+      dryRun: Boolean(flags.dryRun),
+    });
+    writeOutput(
+      this,
+      flags.json
+        ? JSON.stringify(result, null, 2)
+        : makeFactoryNextSteps(result),
+    );
+  },
+});
+
+const makeSeedCommand = buildCommand<MakeFlags, [string], CliContext>({
+  docs: {
+    brief: "Generate a feature seed.",
+  },
+  parameters: {
+    flags: makeFlagParameters,
+    positional: namePositional,
+  },
+  async func(flags, name) {
+    const result = await makeSeed({
+      name,
+      force: Boolean(flags.force),
+      dryRun: Boolean(flags.dryRun),
+    });
+    writeOutput(
+      this,
+      flags.json ? JSON.stringify(result, null, 2) : makeSeedNextSteps(result),
+    );
+  },
+});
+
+const makeNotificationCommand = buildCommand<MakeFlags, [string], CliContext>({
+  docs: {
+    brief: "Generate a feature notification.",
+  },
+  parameters: {
+    flags: makeFlagParameters,
+    positional: namePositional,
+  },
+  async func(flags, name) {
+    const result = await makeNotification({
+      name,
+      force: Boolean(flags.force),
+      dryRun: Boolean(flags.dryRun),
+    });
+    writeOutput(
+      this,
+      flags.json
+        ? JSON.stringify(result, null, 2)
+        : makeNotificationNextSteps(result),
+    );
+  },
+});
+
 const makeListenerFlagParameters = {
   ...makeFlagParameters,
   event: parsedStringFlag("Event to listen to, for example posts/published."),
@@ -617,6 +791,29 @@ const makeScheduleCommand = buildCommand<
   },
 });
 
+const makeUploadCommand = buildCommand<MakeFlags, [string], CliContext>({
+  docs: {
+    brief: "Generate a feature upload.",
+  },
+  parameters: {
+    flags: makeFlagParameters,
+    positional: namePositional,
+  },
+  async func(flags, name) {
+    const result = await makeUpload({
+      name,
+      force: Boolean(flags.force),
+      dryRun: Boolean(flags.dryRun),
+    });
+    writeOutput(
+      this,
+      flags.json
+        ? JSON.stringify(result, null, 2)
+        : makeUploadNextSteps(result),
+    );
+  },
+});
+
 const makeRoutes = buildRouteMap({
   docs: {
     brief: "Generate Beignet app files.",
@@ -625,13 +822,18 @@ const makeRoutes = buildRouteMap({
     adapter: makeAdapterCommand,
     contract: makeContractCommand,
     event: makeEventCommand,
+    factory: makeFactoryCommand,
+    feature: makeFeatureCommand,
     job: makeJobCommand,
+    notification: makeNotificationCommand,
     listener: makeListenerCommand,
     policy: makePolicyCommand,
     port: makePortCommand,
     resource: makeResourceCommand,
     schedule: makeScheduleCommand,
+    seed: makeSeedCommand,
     test: makeTestCommand,
+    upload: makeUploadCommand,
     useCase: makeUseCaseCommand,
   },
 });
@@ -645,6 +847,7 @@ create-beignet <directory> is equivalent to beignet create <directory>.`,
   },
   routes: {
     create: createCommand,
+    db: dbRoutes,
     doctor: doctorCommand,
     lint: lintCommand,
     make: makeRoutes,
@@ -738,6 +941,39 @@ Next steps:
   Run your app's typecheck and test commands.`;
 }
 
+function databaseCommandNextSteps(
+  result: Awaited<ReturnType<typeof runDatabaseCommand>>,
+): string {
+  const command = [result.runner, ...result.args].join(" ");
+  const prefix = result.dryRun ? "Would run" : "Ran";
+
+  return `${prefix} ${result.script} in ${result.cwd}
+
+Command:
+  ${command}`;
+}
+
+function makeFeatureNextSteps(
+  result: Awaited<ReturnType<typeof makeFeature>>,
+): string {
+  const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+    .map((file) => `  ${file}`)
+    .join("\n");
+  const skippedFiles = result.skippedFiles
+    .map((file) => `  ${file}`)
+    .join("\n");
+
+  return `${result.dryRun ? "Would create" : "Created"} ${result.name} feature slice in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Treat the generated name field as a placeholder and shape the contracts, use cases, and repository around the feature's real workflow.
+  Run your app's typecheck, test, beignet lint, and beignet doctor commands.`;
+}
+
 function makeContractNextSteps(
   result: Awaited<ReturnType<typeof makeContract>>,
 ): string {
@@ -904,6 +1140,69 @@ Next steps:
   Dispatch the job through ctx.ports.jobs from a use case, listener, or schedule.`;
 }
 
+function makeFactoryNextSteps(
+  result: Awaited<ReturnType<typeof makeFactory>>,
+): string {
+  const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+    .map((file) => `  ${file}`)
+    .join("\n");
+  const skippedFiles = result.skippedFiles
+    .map((file) => `  ${file}`)
+    .join("\n");
+
+  return `${result.dryRun ? "Would create" : "Created"} ${result.name} factory in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter defaults with realistic test data for this feature.
+  Persist through app-owned repository ports so tests avoid raw database clients.`;
+}
+
+function makeSeedNextSteps(
+  result: Awaited<ReturnType<typeof makeSeed>>,
+): string {
+  const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+    .map((file) => `  ${file}`)
+    .join("\n");
+  const skippedFiles = result.skippedFiles
+    .map((file) => `  ${file}`)
+    .join("\n");
+
+  return `${result.dryRun ? "Would create" : "Created"} ${result.name} seed in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter record with idempotent local or demo data.
+  Import the feature seed from your app-owned database seed entrypoint and run it with runSeeds(...).`;
+}
+
+function makeNotificationNextSteps(
+  result: Awaited<ReturnType<typeof makeNotification>>,
+): string {
+  const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+    .map((file) => `  ${file}`)
+    .join("\n");
+  const skippedFiles = result.skippedFiles
+    .map((file) => `  ${file}`)
+    .join("\n");
+
+  return `${result.dryRun ? "Would create" : "Created"} ${result.name} notification in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter payload and channels with the real user-facing message.
+  Send the notification through ctx.ports.notifications so delivery can run inline in tests and through jobs in production.`;
+}
+
 function makeListenerNextSteps(
   result: Awaited<ReturnType<typeof makeListener>>,
 ): string {
@@ -946,6 +1245,27 @@ Next steps:
   Trigger it from a cron route, worker, or provider adapter.`;
 }
 
+function makeUploadNextSteps(
+  result: Awaited<ReturnType<typeof makeUpload>>,
+): string {
+  const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+    .map((file) => `  ${file}`)
+    .join("\n");
+  const skippedFiles = result.skippedFiles
+    .map((file) => `  ${file}`)
+    .join("\n");
+
+  return `${result.dryRun ? "Would create" : "Created"} ${result.name} upload in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter metadata, constraints, key, authorization, and onComplete behavior.
+  Register the upload in createUploadRouter(...) and expose it with createUploadRoute(...).`;
+}
+
 export async function main(
   inputs = process.argv.slice(2),
   context: StricliDynamicCommandContext<CliContext> = { process },