@beignet/cli 0.0.1 → 0.0.3

package/src/make.ts

@@ -17,6 +17,31 @@ type MakeResourceOptions = {
   config?: BeignetConfig;
 };
 
+export const makeFeatureAddonChoices = [
+  "policy",
+  "event",
+  "events",
+  "job",
+  "jobs",
+  "notification",
+  "notifications",
+  "upload",
+  "uploads",
+] as const;
+
+export type MakeFeatureAddon = (typeof makeFeatureAddonChoices)[number];
+
+type NormalizedMakeFeatureAddon =
+  | "policy"
+  | "event"
+  | "job"
+  | "notification"
+  | "upload";
+
+type MakeFeatureOptions = MakeResourceOptions & {
+  with?: readonly MakeFeatureAddon[];
+};
+
 type MakeContractOptions = {
   name: string;
   cwd?: string;
@@ -81,6 +106,30 @@ type MakeJobOptions = {
   config?: BeignetConfig;
 };
 
+type MakeFactoryOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeSeedOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
+type MakeNotificationOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
 type MakeListenerOptions = {
   name: string;
   event: string;
@@ -101,6 +150,14 @@ type MakeScheduleOptions = {
   route?: boolean;
 };
 
+type MakeUploadOptions = {
+  name: string;
+  cwd?: string;
+  force?: boolean;
+  dryRun?: boolean;
+  config?: BeignetConfig;
+};
+
 type MakeResult = {
   name: string;
   targetDir: string;
@@ -111,17 +168,70 @@ type MakeResult = {
   skippedFiles: string[];
 };
 
+/**
+ * Result returned by `beignet make resource`.
+ */
 export type MakeResourceResult = MakeResult;
+/**
+ * Result returned by `beignet make feature`.
+ */
+export type MakeFeatureResult = MakeResult;
+/**
+ * Result returned by `beignet make contract`.
+ */
 export type MakeContractResult = MakeResult;
+/**
+ * Result returned by `beignet make use-case`.
+ */
 export type MakeUseCaseResult = MakeResult;
+/**
+ * Result returned by `beignet make test`.
+ */
 export type MakeTestResult = MakeResult;
+/**
+ * Result returned by `beignet make port`.
+ */
 export type MakePortResult = MakeResult;
+/**
+ * Result returned by `beignet make adapter`.
+ */
 export type MakeAdapterResult = MakeResult;
+/**
+ * Result returned by `beignet make policy`.
+ */
 export type MakePolicyResult = MakeResult;
+/**
+ * Result returned by `beignet make event`.
+ */
 export type MakeEventResult = MakeResult;
+/**
+ * Result returned by `beignet make job`.
+ */
 export type MakeJobResult = MakeResult;
+/**
+ * Result returned by `beignet make factory`.
+ */
+export type MakeFactoryResult = MakeResult;
+/**
+ * Result returned by `beignet make seed`.
+ */
+export type MakeSeedResult = MakeResult;
+/**
+ * Result returned by `beignet make notification`.
+ */
+export type MakeNotificationResult = MakeResult;
+/**
+ * Result returned by `beignet make listener`.
+ */
 export type MakeListenerResult = MakeResult;
+/**
+ * Result returned by `beignet make schedule`.
+ */
 export type MakeScheduleResult = MakeResult;
+/**
+ * Result returned by `beignet make upload`.
+ */
+export type MakeUploadResult = MakeResult;
 
 type ResourceNames = {
   input: string;
@@ -190,6 +300,23 @@ type JobNames = FeatureArtifactNames & {
   payloadTypeName: string;
 };
 
+type FactoryNames = FeatureArtifactNames & {
+  factoryName: string;
+  factoryExportName: string;
+};
+
+type SeedNames = FeatureArtifactNames & {
+  seedName: string;
+  seedExportName: string;
+};
+
+type NotificationNames = FeatureArtifactNames & {
+  notificationName: string;
+  notificationExportName: string;
+  payloadSchemaName: string;
+  payloadTypeName: string;
+};
+
 type ListenerNames = FeatureArtifactNames & {
   listenerName: string;
   listenerExportName: string;
@@ -205,6 +332,13 @@ type ScheduleNames = FeatureArtifactNames & {
   timezone?: string;
 };
 
+type UploadNames = FeatureArtifactNames & {
+  uploadName: string;
+  uploadExportName: string;
+  metadataSchemaName: string;
+  metadataTypeName: string;
+};
+
 export async function makeResource(
   options: MakeResourceOptions,
 ): Promise<MakeResourceResult> {
@@ -266,6 +400,119 @@ export async function makeResource(
   };
 }
 
+export async function makeFeature(
+  options: MakeFeatureOptions,
+): Promise<MakeFeatureResult> {
+  const addons = normalizeMakeFeatureAddons(options.with ?? []);
+  if (addons.length === 0) {
+    return makeFeatureResource(options);
+  }
+
+  if (options.dryRun) {
+    return makeFeatureSlice(options, addons);
+  }
+
+  await makeFeatureSlice({ ...options, dryRun: true }, addons);
+  return makeFeatureSlice(options, addons);
+}
+
+async function makeFeatureResource(
+  options: MakeResourceOptions,
+): Promise<MakeResourceResult> {
+  try {
+    return await makeResource(options);
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("make resource")) {
+      throw new Error(
+        error.message.replaceAll("make resource", "make feature"),
+      );
+    }
+    throw error;
+  }
+}
+
+async function makeFeatureSlice(
+  options: MakeFeatureOptions,
+  addons: readonly NormalizedMakeFeatureAddon[],
+): Promise<MakeFeatureResult> {
+  let result = await makeFeatureResource(options);
+
+  for (const addon of addons) {
+    result = mergeMakeResults(
+      result,
+      await makeFeatureAddon(addon, result.name, options),
+    );
+  }
+
+  return result;
+}
+
+async function makeFeatureAddon(
+  addon: NormalizedMakeFeatureAddon,
+  feature: string,
+  options: MakeFeatureOptions,
+): Promise<MakeResult> {
+  const shared = {
+    cwd: options.cwd,
+    force: options.force,
+    dryRun: options.dryRun,
+    config: options.config,
+  };
+
+  if (addon === "policy") {
+    return makePolicy({ ...shared, name: feature });
+  }
+  if (addon === "event") {
+    return makeEvent({ ...shared, name: `${feature}/created` });
+  }
+  if (addon === "job") {
+    return makeJob({ ...shared, name: `${feature}/process` });
+  }
+  if (addon === "notification") {
+    return makeNotification({ ...shared, name: `${feature}/created` });
+  }
+
+  return makeUpload({ ...shared, name: `${feature}/attachment` });
+}
+
+function normalizeMakeFeatureAddons(
+  addons: readonly MakeFeatureAddon[],
+): NormalizedMakeFeatureAddon[] {
+  const normalized = new Set<NormalizedMakeFeatureAddon>();
+
+  for (const addon of addons) {
+    if (addon === "events") normalized.add("event");
+    else if (addon === "jobs") normalized.add("job");
+    else if (addon === "notifications") normalized.add("notification");
+    else if (addon === "uploads") normalized.add("upload");
+    else normalized.add(addon);
+  }
+
+  return featureAddonOrder.filter((addon) => normalized.has(addon));
+}
+
+const featureAddonOrder: readonly NormalizedMakeFeatureAddon[] = [
+  "policy",
+  "event",
+  "job",
+  "notification",
+  "upload",
+];
+
+function mergeMakeResults(left: MakeResult, right: MakeResult): MakeResult {
+  return {
+    ...left,
+    files: uniqueStrings([...left.files, ...right.files]),
+    createdFiles: uniqueStrings([...left.createdFiles, ...right.createdFiles]),
+    updatedFiles: uniqueStrings([...left.updatedFiles, ...right.updatedFiles]),
+    skippedFiles: uniqueStrings([...left.skippedFiles, ...right.skippedFiles]),
+  };
+}
+
+function uniqueStrings(values: readonly string[]): string[] {
+  return [...new Set(values)];
+}
+
 export async function makeContract(
   options: MakeContractOptions,
 ): Promise<MakeContractResult> {
@@ -371,7 +618,11 @@ export async function makeTest(
     if (result === "skipped") skippedFiles.push(file.path);
   }
 
-  if (await updatePackageJson(targetDir, { dryRun: Boolean(options.dryRun) })) {
+  if (
+    await updatePackageJson(targetDir, {
+      dryRun: Boolean(options.dryRun),
+    })
+  ) {
     updatedFiles.push("package.json");
   }
 
@@ -578,6 +829,81 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   });
 }
 
+export async function makeFactory(
+  options: MakeFactoryOptions,
+): Promise<MakeFactoryResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = factoryNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertPersistenceArtifactApp(targetDir, names, config, "factory");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: factoryFiles(names, config),
+    index: featureArtifactIndexFile("factory", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
+export async function makeSeed(
+  options: MakeSeedOptions,
+): Promise<MakeSeedResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = seedNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertPersistenceArtifactApp(targetDir, names, config, "seed");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: seedFiles(names, config),
+    index: featureArtifactIndexFile("seed", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
+export async function makeNotification(
+  options: MakeNotificationOptions,
+): Promise<MakeNotificationResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = notificationNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureArtifactApp(targetDir, config, "notification");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: notificationFiles(names, config),
+    index: featureArtifactIndexFile("notification", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
 export async function makeListener(
   options: MakeListenerOptions,
 ): Promise<MakeListenerResult> {
@@ -652,6 +978,31 @@ export async function makeSchedule(
   });
 }
 
+export async function makeUpload(
+  options: MakeUploadOptions,
+): Promise<MakeUploadResult> {
+  const targetDir = path.resolve(options.cwd ?? process.cwd());
+  const names = uploadNames(options.name);
+  const config = options.config
+    ? resolveConfig(options.config)
+    : await loadBeignetConfig(targetDir);
+
+  await assertFeatureArtifactApp(targetDir, config, "upload");
+
+  return makeFeatureArtifact({
+    targetDir,
+    config,
+    force: Boolean(options.force),
+    dryRun: Boolean(options.dryRun),
+    name: `${names.feature.kebab}/${names.artifact.kebab}`,
+    files: uploadFiles(names, config),
+    index: featureArtifactIndexFile("upload", names, config),
+    dependencies: {
+      "@beignet/core": beignetDependencyVersion,
+    },
+  });
+}
+
 async function assertStandardApp(
   targetDir: string,
   config: ResolvedBeignetConfig,
@@ -777,7 +1128,13 @@ async function assertPolicyApp(
 async function assertFeatureArtifactApp(
   targetDir: string,
   config: ResolvedBeignetConfig,
-  artifact: "event" | "job" | "listener" | "schedule",
+  artifact:
+    | "event"
+    | "job"
+    | "notification"
+    | "listener"
+    | "schedule"
+    | "upload",
   options: { requireServer?: boolean } = {},
 ): Promise<void> {
   const requiredFiles = [
@@ -796,6 +1153,29 @@ async function assertFeatureArtifactApp(
   }
 }
 
+async function assertPersistenceArtifactApp(
+  targetDir: string,
+  names: FactoryNames | SeedNames,
+  config: ResolvedBeignetConfig,
+  artifact: "factory" | "seed",
+): Promise<void> {
+  const requiredFiles = [
+    config.paths.appContext,
+    config.paths.ports,
+    resourcePortFilePath(featureResourceNames(names), config),
+  ];
+
+  for (const file of requiredFiles) {
+    try {
+      await stat(path.join(targetDir, file));
+    } catch {
+      throw new Error(
+        `beignet make ${artifact} expects a feature with a repository port. Missing ${file}. Run beignet make feature ${names.feature.kebab} first, or add the repository port before generating ${artifact}s.`,
+      );
+    }
+  }
+}
+
 type WriteGeneratedFileOptions = {
   force: boolean;
   dryRun: boolean;
@@ -996,11 +1376,21 @@ async function updateResourceWiring(
       ? (maybeOptions as { dryRun: boolean })
       : persistenceOrOptions;
   const updated = new Set<string>();
-  if (await updatePackageJson(targetDir, options)) updated.add("package.json");
+  if (
+    await updatePackageJson(targetDir, {
+      ...options,
+      webTestingDependency: true,
+    })
+  ) {
+    updated.add("package.json");
+  }
   if (await updatePortsIndex(targetDir, names, config, options)) {
     updated.add(config.paths.ports);
   }
-  if (await updateInfrastructurePorts(targetDir, names, config, options)) {
+  if (
+    persistence === "memory" &&
+    (await updateInfrastructurePorts(targetDir, names, config, options))
+  ) {
     updated.add(config.paths.infrastructurePorts);
   }
   if (
@@ -1037,17 +1427,27 @@ async function updateResourceWiring(
 
 async function updatePackageJson(
   targetDir: string,
-  options: { dryRun: boolean },
+  options: { dryRun: boolean; webTestingDependency?: boolean },
 ): Promise<boolean> {
   const filePath = path.join(targetDir, "package.json");
   const original = await readFile(filePath, "utf8");
   const packageJson = JSON.parse(original) as {
     scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
   };
   packageJson.scripts = packageJson.scripts ?? {};
-  if (packageJson.scripts.test) return false;
 
-  packageJson.scripts.test = "bun test";
+  packageJson.scripts.test ??= "bun test";
+
+  if (options.webTestingDependency) {
+    packageJson.devDependencies = packageJson.devDependencies ?? {};
+    packageJson.devDependencies["@beignet/web"] ??=
+      packageJson.dependencies?.["@beignet/core"] ??
+      packageJson.dependencies?.["@beignet/next"] ??
+      "*";
+  }
+
   const next = `${JSON.stringify(packageJson, null, "\t")}\n`;
   if (!options.dryRun) await writeFile(filePath, next);
   return next !== original;
@@ -2193,6 +2593,10 @@ function resourceNames(input: string): ResourceNames {
   return names;
 }
 
+function featureResourceNames(names: FeatureArtifactNames): ResourceNames {
+  return resourceNames(names.feature.kebab);
+}
+
 function useCaseNames(input: string): UseCaseNames {
   const parts = input
     .trim()
@@ -2333,6 +2737,49 @@ function jobNames(input: string): JobNames {
   };
 }
 
+function factoryNames(input: string): FactoryNames {
+  const names = featureArtifactNames(input, "Factory");
+  const factoryExportName = `${names.artifact.camel}Factory`;
+
+  assertGeneratedIdentifiers(input, "Factory name", [factoryExportName]);
+
+  return {
+    ...names,
+    factoryName: names.stableName,
+    factoryExportName,
+  };
+}
+
+function seedNames(input: string): SeedNames {
+  const names = featureArtifactNames(input, "Seed");
+  const seedExportName = `${names.artifact.camel}Seed`;
+
+  assertGeneratedIdentifiers(input, "Seed name", [seedExportName]);
+
+  return {
+    ...names,
+    seedName: names.stableName,
+    seedExportName,
+  };
+}
+
+function notificationNames(input: string): NotificationNames {
+  const names = featureArtifactNames(input, "Notification");
+  const notificationExportName = `${names.featureSingularPascal}${names.artifact.pascal}Notification`;
+
+  assertGeneratedIdentifiers(input, "Notification name", [
+    notificationExportName,
+  ]);
+
+  return {
+    ...names,
+    notificationName: names.stableName,
+    notificationExportName,
+    payloadSchemaName: `${notificationExportName}PayloadSchema`,
+    payloadTypeName: `${notificationExportName}Payload`,
+  };
+}
+
 function listenerNames(input: string, eventInput: string): ListenerNames {
   const names = featureArtifactNames(input, "Listener");
   const listenerExportName = names.artifact.camel;
@@ -2367,6 +2814,21 @@ function scheduleNames(
   };
 }
 
+function uploadNames(input: string): UploadNames {
+  const names = featureArtifactNames(input, "Upload");
+  const uploadExportName = `${names.artifact.pascal}Upload`;
+
+  assertGeneratedIdentifiers(input, "Upload name", [uploadExportName]);
+
+  return {
+    ...names,
+    uploadName: names.stableName,
+    uploadExportName,
+    metadataSchemaName: `${uploadExportName}MetadataSchema`,
+    metadataTypeName: `${uploadExportName}Metadata`,
+  };
+}
+
 function normalizeEventReference(input: string): string {
   const trimmed = input.trim();
   if (trimmed.includes("/")) return trimmed;
@@ -2689,6 +3151,42 @@ function jobFiles(
   ];
 }
 
+function notificationFiles(
+  names: NotificationNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: notificationFilePath(names, config),
+      content: notificationFile(names, config),
+    },
+  ];
+}
+
+function factoryFiles(
+  names: FactoryNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: factoryFilePath(names, config),
+      content: factoryFile(names, config),
+    },
+  ];
+}
+
+function seedFiles(
+  names: SeedNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: seedFilePath(names, config),
+      content: seedFile(names, config),
+    },
+  ];
+}
+
 function listenerFiles(
   names: ListenerNames,
   config: ResolvedBeignetConfig,
@@ -2723,6 +3221,18 @@ function scheduleFiles(
   return files;
 }
 
+function uploadFiles(
+  names: UploadNames,
+  config: ResolvedBeignetConfig,
+): GeneratedFile[] {
+  return [
+    {
+      path: uploadFilePath(names, config),
+      content: uploadFile(names, config),
+    },
+  ];
+}
+
 function portFilePath(names: PortNames, config: ResolvedBeignetConfig): string {
   return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
 }
@@ -2917,7 +3427,15 @@ function policyFilePath(
 
 function featureArtifactDir(
   names: FeatureArtifactNames,
-  kind: "events" | "jobs" | "listeners" | "schedules",
+  kind:
+    | "events"
+    | "factories"
+    | "jobs"
+    | "notifications"
+    | "listeners"
+    | "seeds"
+    | "schedules"
+    | "uploads",
   config: ResolvedBeignetConfig,
 ): string {
   const featureDir = path.join(config.paths.features, names.feature.kebab);
@@ -2925,6 +3443,9 @@ function featureArtifactDir(
   if (kind === "events") {
     return path.join(featureDir, "domain", "events");
   }
+  if (kind === "factories") {
+    return path.join(featureDir, "tests", "factories");
+  }
 
   return path.join(featureDir, kind);
 }
@@ -2946,6 +3467,33 @@ function jobFilePath(names: JobNames, config: ResolvedBeignetConfig): string {
   );
 }
 
+function factoryFilePath(
+  names: FactoryNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "factories", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function seedFilePath(names: SeedNames, config: ResolvedBeignetConfig): string {
+  return path.join(
+    featureArtifactDir(names, "seeds", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
+function notificationFilePath(
+  names: NotificationNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "notifications", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
 function listenerFilePath(
   names: ListenerNames,
   config: ResolvedBeignetConfig,
@@ -2966,6 +3514,16 @@ function scheduleFilePath(
   );
 }
 
+function uploadFilePath(
+  names: UploadNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return path.join(
+    featureArtifactDir(names, "uploads", config),
+    `${names.artifact.kebab}.ts`,
+  );
+}
+
 function scheduleRouteFilePath(
   names: ScheduleNames,
   config: ResolvedBeignetConfig,
@@ -3029,14 +3587,40 @@ async function updateUseCaseIndex(
 
 type FeatureArtifactIndexFile = {
   path: string;
+  kind:
+    | "event"
+    | "job"
+    | "factory"
+    | "seed"
+    | "notification"
+    | "listener"
+    | "schedule"
+    | "upload";
   importName: string;
   artifactPath: string;
   registryName: string;
+  registryEntryName: string;
 };
 
 function featureArtifactIndexFile(
-  kind: "event" | "job" | "listener" | "schedule",
-  names: EventNames | JobNames | ListenerNames | ScheduleNames,
+  kind:
+    | "event"
+    | "job"
+    | "factory"
+    | "seed"
+    | "notification"
+    | "listener"
+    | "schedule"
+    | "upload",
+  names:
+    | EventNames
+    | JobNames
+    | FactoryNames
+    | SeedNames
+    | NotificationNames
+    | ListenerNames
+    | ScheduleNames
+    | UploadNames,
   config: ResolvedBeignetConfig,
 ): FeatureArtifactIndexFile {
   const artifactPath =
@@ -3044,31 +3628,57 @@ function featureArtifactIndexFile(
       ? eventFilePath(names as EventNames, config)
       : kind === "job"
         ? jobFilePath(names as JobNames, config)
-        : kind === "listener"
-          ? listenerFilePath(names as ListenerNames, config)
-          : scheduleFilePath(names as ScheduleNames, config);
+        : kind === "factory"
+          ? factoryFilePath(names as FactoryNames, config)
+          : kind === "seed"
+            ? seedFilePath(names as SeedNames, config)
+            : kind === "notification"
+              ? notificationFilePath(names as NotificationNames, config)
+              : kind === "listener"
+                ? listenerFilePath(names as ListenerNames, config)
+                : kind === "schedule"
+                  ? scheduleFilePath(names as ScheduleNames, config)
+                  : uploadFilePath(names as UploadNames, config);
   const registrySuffix =
     kind === "event"
       ? "Events"
       : kind === "job"
         ? "Jobs"
-        : kind === "listener"
-          ? "Listeners"
-          : "Schedules";
+        : kind === "factory"
+          ? "Factories"
+          : kind === "seed"
+            ? "Seeds"
+            : kind === "notification"
+              ? "Notifications"
+              : kind === "listener"
+                ? "Listeners"
+                : kind === "schedule"
+                  ? "Schedules"
+                  : "Uploads";
   const importName =
     kind === "event"
       ? (names as EventNames).eventExportName
       : kind === "job"
         ? (names as JobNames).jobExportName
-        : kind === "listener"
-          ? (names as ListenerNames).listenerExportName
-          : (names as ScheduleNames).scheduleExportName;
+        : kind === "factory"
+          ? (names as FactoryNames).factoryExportName
+          : kind === "seed"
+            ? (names as SeedNames).seedExportName
+            : kind === "notification"
+              ? (names as NotificationNames).notificationExportName
+              : kind === "listener"
+                ? (names as ListenerNames).listenerExportName
+                : kind === "schedule"
+                  ? (names as ScheduleNames).scheduleExportName
+                  : (names as UploadNames).uploadExportName;
 
   return {
     path: path.join(path.dirname(artifactPath), "index.ts"),
+    kind,
     importName,
     artifactPath,
     registryName: `${names.featureSingularCamel}${registrySuffix}`,
+    registryEntryName: names.artifact.camel,
   };
 }
 
@@ -3081,10 +3691,22 @@ async function updateFeatureArtifactIndex(
   const existing = await readOptionalFile(destination);
   const specifier = relativeModule(file.path, file.artifactPath);
   const importLine = `import { ${file.importName} } from "${specifier}";`;
+  const defineUploadsImport = `import { defineUploads } from "@beignet/core/uploads";`;
   const exportLine = `export { ${file.importName} } from "${specifier}";`;
 
   if (existing === undefined) {
-    const content = `${importLine}
+    const content =
+      file.kind === "upload"
+        ? `${defineUploadsImport}
+${importLine}
+
+${exportLine}
+
+export const ${file.registryName} = defineUploads({
+\t${file.registryEntryName}: ${file.importName},
+});
+`
+        : `${importLine}
 
 ${exportLine}
 
@@ -3114,16 +3736,49 @@ export const ${file.registryName} = [${file.importName}] as const;
       : `${next.trimEnd()}\n${exportLine}\n`;
   }
 
-  const registry = arrayInitializerInfo(next, file.registryName);
-  if (!registry) {
-    next = `${next.trimEnd()}\n\nexport const ${file.registryName} = [${file.importName}] as const;\n`;
-  } else if (
-    !identifiersFromArrayExpression(registry.text).has(file.importName)
-  ) {
-    const nextArray = appendToArrayExpression(registry.text, [file.importName]);
-    next = `${next.slice(0, registry.start)}${nextArray}${next.slice(
-      registry.end,
-    )}`;
+  if (file.kind === "upload") {
+    const registry = defineUploadsInitializerInfo(next, file.registryName);
+    const arrayRegistry = arrayInitializerInfo(next, file.registryName);
+    if (registry) {
+      if (!next.includes(defineUploadsImport)) {
+        next = insertAfterImports(next, defineUploadsImport);
+      }
+      if (!registry.text.includes(`${file.registryEntryName}:`)) {
+        next = `${next.slice(0, registry.end)}\t${file.registryEntryName}: ${file.importName},\n${next.slice(
+          registry.end,
+        )}`;
+      }
+    } else if (arrayRegistry) {
+      if (
+        !identifiersFromArrayExpression(arrayRegistry.text).has(file.importName)
+      ) {
+        const nextArray = appendToArrayExpression(arrayRegistry.text, [
+          file.importName,
+        ]);
+        next = `${next.slice(0, arrayRegistry.start)}${nextArray}${next.slice(
+          arrayRegistry.end,
+        )}`;
+      }
+    } else {
+      if (!next.includes(defineUploadsImport)) {
+        next = insertAfterImports(next, defineUploadsImport);
+      }
+      next = `${next.trimEnd()}\n\nexport const ${file.registryName} = defineUploads({\n\t${file.registryEntryName}: ${file.importName},\n});\n`;
+    }
+  } else {
+    const registry = arrayInitializerInfo(next, file.registryName);
+    if (!registry) {
+      next = `${next.trimEnd()}\n\nexport const ${file.registryName} = [${file.importName}] as const;\n`;
+    } else if (
+      !identifiersFromArrayExpression(registry.text).has(file.importName)
+    ) {
+      const nextArray = appendToArrayExpression(registry.text, [
+        file.importName,
+      ]);
+      next = `${next.slice(0, registry.start)}${nextArray}${next.slice(
+        registry.end,
+      )}`;
+    }
   }
 
   if (next === existing) return "skipped";
@@ -3151,6 +3806,28 @@ function arrayInitializerInfo(
   };
 }
 
+function defineUploadsInitializerInfo(
+  source: string,
+  constName: string,
+): { text: string; start: number; end: number } | undefined {
+  const match = new RegExp(
+    `\\bconst\\s+${constName}\\s*=\\s*defineUploads\\s*\\(`,
+  ).exec(source);
+  if (!match) return undefined;
+
+  const openBrace = source.indexOf("{", match.index);
+  if (openBrace === -1) return undefined;
+
+  const closeBrace = matchingDelimiterIndex(source, openBrace, "{", "}");
+  if (closeBrace === -1) return undefined;
+
+  return {
+    text: source.slice(openBrace, closeBrace + 1),
+    start: openBrace,
+    end: closeBrace,
+  };
+}
+
 function schemasFile(names: ResourceNames): string {
   return `import { z } from "zod";
 
@@ -3166,10 +3843,14 @@ export const List${names.pluralPascal}InputSchema = z.object({
 });
 
 export const List${names.pluralPascal}OutputSchema = z.object({
-	${names.pluralCamel}: z.array(${names.singularPascal}Schema),
-	total: z.number().int().min(0),
-	limit: z.number().int().min(1),
-	offset: z.number().int().min(0),
+	items: z.array(${names.singularPascal}Schema),
+	page: z.object({
+		kind: z.literal("offset"),
+		limit: z.number().int().min(1),
+		offset: z.number().int().min(0),
+		total: z.number().int().min(0),
+		hasMore: z.boolean(),
+	}),
 });
 
 export const Create${names.singularPascal}InputSchema = z.object({
@@ -3195,7 +3876,8 @@ function listUseCaseFile(
     `list-${names.pluralKebab}.ts`,
   );
 
-  return `import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
+  return `import { normalizeOffsetPage } from "@beignet/core/pagination";
+import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
 	List${names.pluralPascal}InputSchema,
 	List${names.pluralPascal}OutputSchema,
@@ -3206,13 +3888,12 @@ export const list${names.pluralPascal}UseCase = useCase
 	.input(List${names.pluralPascal}InputSchema)
 	.output(List${names.pluralPascal}OutputSchema)
 	.run(async ({ ctx, input }) => {
-		const result = await ctx.ports.${names.pluralCamel}.list(input);
-		return {
-			${names.pluralCamel}: result.${names.pluralCamel},
-			total: result.total,
-			limit: input.limit,
-			offset: input.offset,
-		};
+		const page = normalizeOffsetPage(input, {
+			defaultLimit: 20,
+			maxLimit: 100,
+		});
+
+		return ctx.ports.${names.pluralCamel}.list(page);
 	});
 `;
 }
@@ -3260,18 +3941,19 @@ function repositoryPortFile(
   config: ResolvedBeignetConfig,
 ): string {
   return `import type {
+	OffsetPage,
+	OffsetPageInfo,
+	PageResult,
+} from "@beignet/core/pagination";
+import type {
 	Create${names.singularPascal}Input,
-	List${names.pluralPascal}Input,
 	${names.singularPascal},
 } from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
 
-export type List${names.pluralPascal}Result = {
-	${names.pluralCamel}: ${names.singularPascal}[];
-	total: number;
-};
+export type List${names.pluralPascal}Result = PageResult<${names.singularPascal}, OffsetPageInfo>;
 
 export interface ${names.singularPascal}Repository {
-	list(input: List${names.pluralPascal}Input): Promise<List${names.pluralPascal}Result>;
+	list(page: OffsetPage): Promise<List${names.pluralPascal}Result>;
 	create(input: Create${names.singularPascal}Input): Promise<${names.singularPascal}>;
 }
 `;
@@ -3283,10 +3965,10 @@ function inMemoryRepositoryFile(
 ): string {
   const repositoryPortPath = resourcePortFilePath(names, config);
 
-  return `import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
+  return `import { offsetPageResult } from "@beignet/core/pagination";
+import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
 import type {
 	Create${names.singularPascal}Input,
-	List${names.pluralPascal}Input,
 	${names.singularPascal},
 } from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
 
@@ -3296,18 +3978,16 @@ export function createInMemory${names.singularPascal}Repository(
 	const ${names.pluralCamel} = new Map(seed.map((${names.singularCamel}) => [${names.singularCamel}.id, ${names.singularCamel}]));
 
 	return {
-		async list(input: List${names.pluralPascal}Input) {
+		async list(page) {
 			const all${names.pluralPascal} = Array.from(${names.pluralCamel}.values()).sort(
 				(left, right) => right.createdAt.localeCompare(left.createdAt),
 			);
 
-			return {
-				${names.pluralCamel}: all${names.pluralPascal}.slice(
-					input.offset,
-					input.offset + input.limit,
-				),
-				total: all${names.pluralPascal}.length,
-			};
+			return offsetPageResult(
+				all${names.pluralPascal}.slice(page.offset, page.offset + page.limit),
+				page,
+				all${names.pluralPascal}.length,
+			);
 		},
 		async create(input: Create${names.singularPascal}Input) {
 			const ${names.singularCamel}: ${names.singularPascal} = {
@@ -3341,12 +4021,12 @@ function drizzleRepositoryFile(
   const repositoryPortPath = resourcePortFilePath(names, config);
   const schemaPath = drizzleSchemaIndexPath(config);
 
-  return `import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
+  return `import { offsetPageResult } from "@beignet/core/pagination";
+import type { DrizzleTursoDatabase } from "@beignet/provider-drizzle-turso";
 import { count, desc } from "drizzle-orm";
 import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
 import type {
 	Create${names.singularPascal}Input,
-	List${names.pluralPascal}Input,
 	${names.singularPascal},
 } from "${aliasModule(path.join(resourceUseCaseDir(names, config), "schemas.ts"))}";
 import * as schema from "${aliasModule(schemaPath)}";
@@ -3365,21 +4045,18 @@ export function createDrizzle${names.singularPascal}Repository(
 	db: DrizzleTursoDatabase<typeof schema>,
 ): ${names.singularPascal}Repository {
 	return {
-		async list(input: List${names.pluralPascal}Input) {
+		async list(page) {
 			const rows = await db
 				.select()
 				.from(schema.${names.pluralCamel})
 				.orderBy(desc(schema.${names.pluralCamel}.createdAt))
-				.limit(input.limit)
-				.offset(input.offset);
+				.limit(page.limit)
+				.offset(page.offset);
 			const [{ total }] = await db
 				.select({ total: count() })
 				.from(schema.${names.pluralCamel});
 
-			return {
-				${names.pluralCamel}: rows.map(to${names.singularPascal}),
-				total,
-			};
+			return offsetPageResult(rows.map(to${names.singularPascal}), page, total);
 		},
 		async create(input: Create${names.singularPascal}Input) {
 			const [row] = await db
@@ -3472,10 +4149,14 @@ export const list${names.pluralPascal} = ${names.pluralCamel}
 	)
 	.responses({
 		200: z.object({
-			${names.pluralCamel}: z.array(${names.singularCamel}Schema),
-			total: z.number().int().min(0),
-			limit: z.number().int().min(1),
-			offset: z.number().int().min(0),
+			items: z.array(${names.singularCamel}Schema),
+			page: z.object({
+				kind: z.literal("offset"),
+				limit: z.number().int().min(1),
+				offset: z.number().int().min(0),
+				total: z.number().int().min(0),
+				hasMore: z.boolean(),
+			}),
 		}),
 	});
 
@@ -3532,7 +4213,7 @@ describe("${names.exportName}", () => {
 			...appPorts,
 			uow: createNoopUnitOfWork(
 				() => appPorts as unknown as AppContext["ports"],
-			) as AppContext["ports"]["uow"],
+			) as unknown as AppContext["ports"]["uow"],
 			devtools: createInMemoryDevtools(),
 			storage: createMemoryStorage(),
 		} as AppContext["ports"];
@@ -3626,7 +4307,7 @@ export const ${names.eventExportName} = defineEvent("${names.eventName}", {
 }
 
 function jobFile(names: JobNames, config: ResolvedBeignetConfig): string {
-  return `import { createJobHandlers } from "@beignet/core/jobs";
+  return `import { createJobHandlers, retry } from "@beignet/core/jobs";
 import { z } from "zod";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
 
@@ -3640,9 +4321,11 @@ export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}
 
 export const ${names.jobExportName} = jobs.defineJob("${names.jobName}", {
 \tpayload: ${names.payloadSchemaName},
-\tretry: {
+\tretry: retry.exponential({
 \t\tattempts: 3,
-\t},
+\t\tinitialDelay: "1s",
+\t\tmaxDelay: "1m",
+\t}),
 \tasync handle({ payload, ctx }) {
 \t\tctx.ports.logger.info("Job handled", {
 \t\t\tjobName: "${names.jobName}",
@@ -3653,6 +4336,78 @@ export const ${names.jobExportName} = jobs.defineJob("${names.jobName}", {
 `;
 }
 
+function factoryFile(
+  names: FactoryNames,
+  config: ResolvedBeignetConfig,
+): string {
+  const resource = featureResourceNames(names);
+
+  return `import { defineFactory } from "@beignet/core/testing";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const ${names.factoryExportName} = defineFactory("${names.factoryName}", {
+\tdefaults: ({ sequence }) => ({
+\t\tname: "${resource.singularPascal} " + sequence,
+\t}),
+\tpersist: (ctx: AppContext, input) => ctx.ports.${resource.pluralCamel}.create(input),
+});
+`;
+}
+
+function seedFile(names: SeedNames, config: ResolvedBeignetConfig): string {
+  const resource = featureResourceNames(names);
+
+  return `import { defineSeed } from "@beignet/core/testing";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const ${names.seedExportName} = defineSeed("${names.seedName}", {
+\tdescription: "Creates starter ${names.feature.kebab} data.",
+\trun: async (ctx: AppContext) => {
+\t\tawait ctx.ports.${resource.pluralCamel}.create({
+\t\t\tname: "Demo ${resource.singularPascal}",
+\t\t});
+\t},
+});
+`;
+}
+
+function notificationFile(
+  names: NotificationNames,
+  config: ResolvedBeignetConfig,
+): string {
+  return `import {
+\tcreateNotificationHandlers,
+\tdefineMailNotificationChannel,
+} from "@beignet/core/notifications";
+import { z } from "zod";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+const notifications = createNotificationHandlers<AppContext>();
+
+export const ${names.payloadSchemaName} = z.object({
+\tid: z.string().uuid(),
+\tsubject: z.string(),
+\trecipientEmail: z.string().email(),
+});
+
+export type ${names.payloadTypeName} = z.infer<typeof ${names.payloadSchemaName}>;
+
+export const ${names.notificationExportName} = notifications.defineNotification(
+\t"${names.notificationName}",
+\t{
+\t\tpayload: ${names.payloadSchemaName},
+\t\tchannels: {
+\t\t\temail: defineMailNotificationChannel(({ payload }) => ({
+\t\t\t\tto: payload.recipientEmail,
+\t\t\t\tsubject: payload.subject,
+\t\t\t\ttext: \`${names.notificationName} notification for \${payload.id}.\`,
+\t\t\t})),
+\t\t},
+\t},
+);
+`;
+}
+
 function listenerFile(
   names: ListenerNames,
   config: ResolvedBeignetConfig,
@@ -3716,6 +4471,61 @@ ${names.timezone ? `\t\ttimezone: "${names.timezone}",\n` : ""}\t\tpayload: ${na
 `;
 }
 
+function uploadFile(names: UploadNames, config: ResolvedBeignetConfig): string {
+  return `import { defineUpload } from "@beignet/core/uploads";
+import { z } from "zod";
+import type { AppContext } from "${aliasModule(config.paths.appContext)}";
+
+export const ${names.metadataSchemaName} = z.object({
+\tresourceId: z.string().min(1),
+});
+
+export type ${names.metadataTypeName} = z.infer<typeof ${names.metadataSchemaName}>;
+
+export const ${names.uploadExportName} = defineUpload<
+\t"${names.uploadName}",
+\ttypeof ${names.metadataSchemaName},
+\tAppContext,
+\t{ objectKeys: string[] }
+>("${names.uploadName}", {
+\tmetadata: ${names.metadataSchemaName},
+\tfile: {
+\t\tcontentTypes: ["application/pdf", "text/plain"],
+\t\tmaxSizeBytes: 5 * 1024 * 1024,
+\t\tmaxFiles: 1,
+\t\tvisibility: "private",
+\t\tcacheControl: "private, max-age=0",
+\t},
+\tauthorize({ ctx }) {
+\t\treturn ctx.actor.type === "user";
+\t},
+\tkey({ ctx, metadata, uploadId, file }) {
+\t\tconst tenantId = ctx.tenant?.id ?? "default";
+\t\tconst extension = file.name.includes(".") ? file.name.split(".").pop() : undefined;
+\t\tconst suffix = extension ? \`.\${extension}\` : "";
+\t\treturn "${names.feature.kebab}/" + tenantId + "/" + metadata.resourceId + "/" + uploadId + suffix;
+\t},
+\tstorageMetadata({ ctx, metadata }) {
+\t\treturn {
+\t\t\ttenantId: ctx.tenant?.id ?? "default",
+\t\t\tresourceId: metadata.resourceId,
+\t\t};
+\t},
+\tasync onComplete({ ctx, metadata, files }) {
+\t\tctx.ports.logger.info("Upload completed", {
+\t\t\tuploadName: "${names.uploadName}",
+\t\t\tresourceId: metadata.resourceId,
+\t\t\tobjectKeys: files.map((file) => file.key),
+\t\t});
+
+\t\treturn {
+\t\t\tobjectKeys: files.map((file) => file.key),
+\t\t};
+\t},
+});
+`;
+}
+
 function scheduleRouteFile(
   names: ScheduleNames,
   config: ResolvedBeignetConfig,
@@ -3878,11 +4688,15 @@ function testFile(names: ResourceNames, config: ResolvedBeignetConfig): string {
 
   return `import { describe, expect, it } from "bun:test";
 import { createUseCaseTester } from "@beignet/core/application";
+import { defineRoutes } from "@beignet/web";
+import { createTestApp } from "@beignet/web/testing";
 import { createInMemoryDevtools } from "@beignet/devtools";
 import { createAnonymousActor, createMemoryStorage, createNoopUnitOfWork } from "@beignet/core/ports";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
 import { appPorts } from "${aliasModule(config.paths.infrastructurePorts)}";
+import { create${names.singularPascal}, list${names.pluralPascal} } from "${aliasModule(resourceContractFilePath(names, config))}";
 import { createInMemory${names.singularPascal}Repository } from "${aliasModule(repositoryPath)}";
+import { ${names.singularCamel}Routes } from "${aliasModule(path.join(resourceFeatureDir(names, config), "routes.ts"))}";
 import {
 	create${names.singularPascal}UseCase,
 	list${names.pluralPascal}UseCase,
@@ -3897,18 +4711,19 @@ describe("${names.pluralCamel} resource", () => {
 			uow: createNoopUnitOfWork(() => ({
 				...(appPorts as unknown as AppContext["ports"]),
 				${names.pluralCamel},
-			})) as AppContext["ports"]["uow"],
+			})) as unknown as AppContext["ports"]["uow"],
 			devtools: createInMemoryDevtools(),
 			storage: createMemoryStorage(),
 		} as AppContext["ports"];
 		const actor = createAnonymousActor();
-		const tester = createUseCaseTester<AppContext>(() => ({
+		const createTestContext = () => ({
 			requestId: "test-request",
 			actor,
 			auth: null,
 			gate: testPorts.gate.bind({ actor, auth: null }),
 			ports: testPorts,
-		}));
+		});
+		const tester = createUseCaseTester<AppContext>(createTestContext);
 
 		const ctx = await tester.ctx();
 		const created = await tester.run(
@@ -3923,8 +4738,30 @@ describe("${names.pluralCamel} resource", () => {
 		);
 
 		expect(created.name).toBe("First ${names.singularPascal}");
-		expect(result.total).toBe(1);
-		expect(result.${names.pluralCamel}).toEqual([created]);
+		expect(result.page.total).toBe(1);
+		expect(result.items).toEqual([created]);
+
+		const app = await createTestApp<AppContext, AppContext["ports"]>({
+			ports: testPorts,
+			routes: defineRoutes<AppContext>([${names.singularCamel}Routes]),
+			createContext: async () => createTestContext(),
+			mapUnhandledError: () => ({
+				status: 500,
+				body: { code: "INTERNAL_SERVER_ERROR", message: "Internal server error" },
+			}),
+		});
+
+		const createdViaRoute = await app.request(create${names.singularPascal}, {
+			body: { name: "Second ${names.singularPascal}" },
+		});
+		const listedViaRoute = await app.request(list${names.pluralPascal}, {
+			query: { limit: 20, offset: 0 },
+		});
+		await app.stop();
+
+		expect(createdViaRoute.name).toBe("Second ${names.singularPascal}");
+		expect(listedViaRoute.page.total).toBe(2);
+		expect(listedViaRoute.items).toContainEqual(createdViaRoute);
 	});
 });
 `;