@beignet/cli 0.0.1 → 0.0.3

package/dist/make.js

@@ -1,6 +1,17 @@
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
+export const makeFeatureAddonChoices = [
+    "policy",
+    "event",
+    "events",
+    "job",
+    "jobs",
+    "notification",
+    "notifications",
+    "upload",
+    "uploads",
+];
 export async function makeResource(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = resourceNames(options.name);
@@ -47,6 +58,91 @@ export async function makeResource(options) {
         skippedFiles,
     };
 }
+export async function makeFeature(options) {
+    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) {
+    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, addons) {
+    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, feature, options) {
+    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) {
+    const normalized = new Set();
+    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 = [
+    "policy",
+    "event",
+    "job",
+    "notification",
+    "upload",
+];
+function mergeMakeResults(left, right) {
+    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) {
+    return [...new Set(values)];
+}
 export async function makeContract(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = resourceNames(options.name);
@@ -145,7 +241,9 @@ export async function makeTest(options) {
         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");
     }
     return {
@@ -320,6 +418,66 @@ export async function makeJob(options) {
         },
     });
 }
+export async function makeFactory(options) {
+    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) {
+    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) {
+    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) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = listenerNames(options.name, options.event);
@@ -376,6 +534,26 @@ export async function makeSchedule(options) {
         },
     });
 }
+export async function makeUpload(options) {
+    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, config) {
     const requiredFiles = [
         config.paths.appContext,
@@ -468,6 +646,21 @@ async function assertFeatureArtifactApp(targetDir, config, artifact, options = {
         }
     }
 }
+async function assertPersistenceArtifactApp(targetDir, names, config, artifact) {
+    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.`);
+        }
+    }
+}
 async function writeGeneratedFile(targetDir, file, options) {
     const plannedFile = await planGeneratedFile(targetDir, file, {
         force: options.force,
@@ -587,12 +780,17 @@ async function updateResourceWiring(targetDir, names, config, persistenceOrOptio
         ? maybeOptions
         : persistenceOrOptions;
     const updated = new Set();
-    if (await updatePackageJson(targetDir, options))
+    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 (persistence === "drizzle" &&
@@ -620,9 +818,14 @@ async function updatePackageJson(targetDir, options) {
     const original = await readFile(filePath, "utf8");
     const packageJson = JSON.parse(original);
     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);
@@ -1383,6 +1586,9 @@ function resourceNames(input) {
     ]);
     return names;
 }
+function featureResourceNames(names) {
+    return resourceNames(names.feature.kebab);
+}
 function useCaseNames(input) {
     const parts = input
         .trim()
@@ -1497,6 +1703,40 @@ function jobNames(input) {
         payloadTypeName: `${jobExportName}Payload`,
     };
 }
+function factoryNames(input) {
+    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) {
+    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) {
+    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, eventInput) {
     const names = featureArtifactNames(input, "Listener");
     const listenerExportName = names.artifact.camel;
@@ -1522,6 +1762,18 @@ function scheduleNames(input, options) {
         timezone: options.timezone?.trim() || undefined,
     };
 }
+function uploadNames(input) {
+    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) {
     const trimmed = input.trim();
     if (trimmed.includes("/"))
@@ -1767,6 +2019,30 @@ function jobFiles(names, config) {
         },
     ];
 }
+function notificationFiles(names, config) {
+    return [
+        {
+            path: notificationFilePath(names, config),
+            content: notificationFile(names, config),
+        },
+    ];
+}
+function factoryFiles(names, config) {
+    return [
+        {
+            path: factoryFilePath(names, config),
+            content: factoryFile(names, config),
+        },
+    ];
+}
+function seedFiles(names, config) {
+    return [
+        {
+            path: seedFilePath(names, config),
+            content: seedFile(names, config),
+        },
+    ];
+}
 function listenerFiles(names, config) {
     return [
         {
@@ -1790,6 +2066,14 @@ function scheduleFiles(names, config, options) {
     }
     return files;
 }
+function uploadFiles(names, config) {
+    return [
+        {
+            path: uploadFilePath(names, config),
+            content: uploadFile(names, config),
+        },
+    ];
+}
 function portFilePath(names, config) {
     return path.join(path.dirname(config.paths.ports), `${names.kebab}.ts`);
 }
@@ -1882,6 +2166,9 @@ function featureArtifactDir(names, kind, config) {
     if (kind === "events") {
         return path.join(featureDir, "domain", "events");
     }
+    if (kind === "factories") {
+        return path.join(featureDir, "tests", "factories");
+    }
     return path.join(featureDir, kind);
 }
 function eventFilePath(names, config) {
@@ -1890,12 +2177,24 @@ function eventFilePath(names, config) {
 function jobFilePath(names, config) {
     return path.join(featureArtifactDir(names, "jobs", config), `${names.artifact.kebab}.ts`);
 }
+function factoryFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "factories", config), `${names.artifact.kebab}.ts`);
+}
+function seedFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "seeds", config), `${names.artifact.kebab}.ts`);
+}
+function notificationFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "notifications", config), `${names.artifact.kebab}.ts`);
+}
 function listenerFilePath(names, config) {
     return path.join(featureArtifactDir(names, "listeners", config), `${names.artifact.kebab}.ts`);
 }
 function scheduleFilePath(names, config) {
     return path.join(featureArtifactDir(names, "schedules", config), `${names.artifact.kebab}.ts`);
 }
+function uploadFilePath(names, config) {
+    return path.join(featureArtifactDir(names, "uploads", config), `${names.artifact.kebab}.ts`);
+}
 function scheduleRouteFilePath(names, config) {
     return path.join(config.paths.routes, "cron", names.feature.kebab, names.artifact.kebab, "route.ts");
 }
@@ -1932,28 +2231,54 @@ function featureArtifactIndexFile(kind, names, config) {
         ? eventFilePath(names, config)
         : kind === "job"
             ? jobFilePath(names, config)
-            : kind === "listener"
-                ? listenerFilePath(names, config)
-                : scheduleFilePath(names, config);
+            : kind === "factory"
+                ? factoryFilePath(names, config)
+                : kind === "seed"
+                    ? seedFilePath(names, config)
+                    : kind === "notification"
+                        ? notificationFilePath(names, config)
+                        : kind === "listener"
+                            ? listenerFilePath(names, config)
+                            : kind === "schedule"
+                                ? scheduleFilePath(names, config)
+                                : uploadFilePath(names, 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.eventExportName
         : kind === "job"
             ? names.jobExportName
-            : kind === "listener"
-                ? names.listenerExportName
-                : names.scheduleExportName;
+            : kind === "factory"
+                ? names.factoryExportName
+                : kind === "seed"
+                    ? names.seedExportName
+                    : kind === "notification"
+                        ? names.notificationExportName
+                        : kind === "listener"
+                            ? names.listenerExportName
+                            : kind === "schedule"
+                                ? names.scheduleExportName
+                                : names.uploadExportName;
     return {
         path: path.join(path.dirname(artifactPath), "index.ts"),
+        kind,
         importName,
         artifactPath,
         registryName: `${names.featureSingularCamel}${registrySuffix}`,
+        registryEntryName: names.artifact.camel,
     };
 }
 async function updateFeatureArtifactIndex(targetDir, file, options) {
@@ -1961,9 +2286,20 @@ async function updateFeatureArtifactIndex(targetDir, file, options) {
     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}
 
@@ -1985,13 +2321,43 @@ export const ${file.registryName} = [${file.importName}] as const;
             ? `${next.slice(0, registryExport.index).trimEnd()}\n${exportLine}\n\n${next.slice(registryExport.index)}`
             : `${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`;
+    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 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)}`;
+    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";
@@ -2015,6 +2381,22 @@ function arrayInitializerInfo(source, constName) {
         end: closeBracket + 1,
     };
 }
+function defineUploadsInitializerInfo(source, constName) {
+    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) {
     return `import { z } from "zod";
 
@@ -2030,10 +2412,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({
@@ -2051,7 +2437,8 @@ export type List${names.pluralPascal}Input = z.infer<
 }
 function listUseCaseFile(names, config) {
     const filePath = path.join(resourceUseCaseDir(names, config), `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,
@@ -2062,13 +2449,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);
 	});
 `;
 }
@@ -2103,28 +2489,29 @@ export {
 }
 function repositoryPortFile(names, config) {
     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}>;
 }
 `;
 }
 function inMemoryRepositoryFile(names, config) {
     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"))}";
 
@@ -2134,18 +2521,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} = {
@@ -2173,12 +2558,12 @@ export const ${names.pluralCamel} = sqliteTable("${names.pluralKebab.replaceAll(
 function drizzleRepositoryFile(names, config) {
     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)}";
@@ -2197,21 +2582,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
@@ -2299,10 +2681,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(),
+			}),
 		}),
 	});
 
@@ -2349,7 +2735,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"];
@@ -2437,7 +2823,7 @@ export const ${names.eventExportName} = defineEvent("${names.eventName}", {
 `;
 }
 function jobFile(names, config) {
-    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)}";
 
@@ -2451,9 +2837,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}",
@@ -2463,6 +2851,67 @@ export const ${names.jobExportName} = jobs.defineJob("${names.jobName}", {
 });
 `;
 }
+function factoryFile(names, config) {
+    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, config) {
+    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, config) {
+    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, config) {
     const filePath = listenerFilePath(names, config);
     return `import { createEventHandlers } from "@beignet/core/events";
@@ -2517,6 +2966,60 @@ ${names.timezone ? `\t\ttimezone: "${names.timezone}",\n` : ""}\t\tpayload: ${na
 );
 `;
 }
+function uploadFile(names, config) {
+    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, config) {
     return `import { createInlineScheduleRunner } from "@beignet/core/schedules";
 import type { AppContext } from "${aliasModule(config.paths.appContext)}";
@@ -2665,11 +3168,15 @@ function testFile(names, config) {
     const repositoryPath = path.join(path.dirname(config.paths.infrastructurePorts), names.pluralKebab, `in-memory-${names.singularKebab}-repository.ts`);
     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,
@@ -2684,18 +3191,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(
@@ -2710,8 +3218,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);
 	});
 });
 `;