@beignet/cli 0.0.22 → 0.0.24

package/dist/make.js

@@ -3,7 +3,7 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { clientIndexPath, directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
 import { appendToArrayExpression, appendToNamedArray, appendToOutboxRegistryArray, arrayInitializerInfo, identifiersFromArrayExpression, insertAfterImports, matchingDelimiterIndex, } from "./registry-edits.js";
-export { makeFeatureAddonChoices } from "./choices.js";
+export { makeFeatureAddonChoices, makeFeatureRecipeChoices, } from "./choices.js";
 const drizzleDialects = {
     sqlite: {
         subpath: "sqlite",
@@ -43,15 +43,23 @@ export async function makeResource(options) {
     return makeResourceSlice(options, "resource");
 }
 export async function makeFeature(options) {
-    const addons = normalizeMakeFeatureAddons(options.with ?? []);
+    const addons = normalizeMakeFeatureAddons([
+        ...makeFeatureRecipeAddons(options.recipe),
+        ...(options.with ?? []),
+        ...(options.events ? ["events"] : []),
+    ]);
+    const featureOptions = {
+        ...options,
+        events: addons.includes("event"),
+    };
     if (addons.length === 0) {
-        return makeFeatureResource(options);
+        return makeFeatureResource(featureOptions);
     }
     if (options.dryRun) {
-        return makeFeatureSlice(options, addons);
+        return makeFeatureSlice(featureOptions, addons);
     }
-    await makeFeatureSlice({ ...options, dryRun: true }, addons);
-    return makeFeatureSlice(options, addons);
+    await makeFeatureSlice({ ...featureOptions, dryRun: true }, addons);
+    return makeFeatureSlice(featureOptions, addons);
 }
 export async function makePayments(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
@@ -191,6 +199,14 @@ async function makeResourceSlice(options, mode) {
     };
 }
 function resourceGenerationOptions(options, mode) {
+    if (mode === "feature") {
+        return {
+            auth: false,
+            tenant: false,
+            events: Boolean(options.events),
+            softDelete: false,
+        };
+    }
     if (mode !== "resource") {
         return { auth: false, tenant: false, events: false, softDelete: false };
     }
@@ -292,6 +308,24 @@ function normalizeMakeFeatureAddons(addons) {
     }
     return featureAddonOrder.filter((addon) => normalized.has(addon));
 }
+function makeFeatureRecipeAddons(recipe) {
+    if (recipe === "full-slice") {
+        return [
+            "policy",
+            "factories",
+            "seeds",
+            "tasks",
+            "events",
+            "listeners",
+            "jobs",
+            "notifications",
+            "schedules",
+            "ui",
+            "uploads",
+        ];
+    }
+    return [];
+}
 const featureAddonOrder = [
     "policy",
     "factory",
@@ -815,7 +849,10 @@ export async function makeListener(options) {
     if (!options.skipEventAssert) {
         await assertListenerEventExists(targetDir, names.event, config);
     }
-    return makeFeatureArtifact({
+    await updateListenerProviderWiring(targetDir, names, config, {
+        dryRun: true,
+    });
+    const result = await makeFeatureArtifact({
         targetDir,
         config,
         force: Boolean(options.force),
@@ -830,6 +867,19 @@ export async function makeListener(options) {
             "@beignet/core": beignetDependencyVersion,
         },
     });
+    const providerResult = await updateListenerProviderWiring(targetDir, names, config, {
+        dryRun: Boolean(options.dryRun),
+    });
+    if (providerResult === "created")
+        result.createdFiles.push(providersFilePath(config));
+    if (providerResult === "updated")
+        result.updatedFiles.push(providersFilePath(config));
+    if (providerResult === "skipped")
+        result.skippedFiles.push(providersFilePath(config));
+    if (!result.files.includes(providersFilePath(config))) {
+        result.files.push(providersFilePath(config));
+    }
+    return result;
 }
 async function assertListenerEventExists(targetDir, names, config) {
     const file = eventFilePath(names, config);
@@ -840,6 +890,73 @@ async function assertListenerEventExists(targetDir, names, config) {
         throw new Error(`beignet make listener expected event ${names.eventName} at ${file}. Run beignet make event ${names.feature.kebab}/${names.artifact.kebab} first, or pass an event that exists.`);
     }
 }
+async function updateListenerProviderWiring(targetDir, names, config, options) {
+    const providersFile = providersFilePath(config);
+    const filePath = path.join(targetDir, providersFile);
+    const original = await readOptionalFile(filePath);
+    if (original === undefined) {
+        throw new Error(`Could not find the generated providers file ${providersFile}. Register listeners manually with registerListeners(...), or restore the generated providers file before running make listener.`);
+    }
+    const listenerIndex = featureArtifactIndexFile("listener", names, config);
+    const providerName = `${names.featureSingularCamel}ListenersProvider`;
+    let next = original;
+    next = addNamedImport(next, "registerListeners", "@beignet/core/events");
+    next = addNamedImport(next, "createServiceActor", "@beignet/core/ports");
+    next = addNamedImport(next, "createProvider", "@beignet/core/providers");
+    next = addNamedTypeImport(next, "AppContext", aliasModule(config.paths.appContext));
+    next = addNamedTypeImport(next, "AppServiceContextInput", aliasModule(path.join(path.dirname(config.paths.server), "context.ts")));
+    next = addNamedTypeImport(next, "AppPorts", aliasModule(config.paths.ports));
+    const listenerImport = `import { ${listenerIndex.registryName} } from "${aliasModule(listenerIndex.path)}";`;
+    if (!next.includes(listenerImport)) {
+        next = insertAfterImports(next, listenerImport);
+    }
+    if (!new RegExp(`\\bconst\\s+${providerName}\\b`).test(next)) {
+        const providerDefinition = `const ${providerName} = createProvider<
+\tPick<AppPorts, "eventBus" | "logger">,
+\tAppContext,
+\tAppServiceContextInput
+>()({
+\tname: "${names.feature.kebab}-listeners",
+\tsetup({ ports, createServiceContext }) {
+\t\tconst unregister = registerListeners(ports.eventBus, ${listenerIndex.registryName}, {
+\t\t\tctx: () =>
+\t\t\t\tcreateServiceContext({
+\t\t\t\t\tactor: createServiceActor("beignet-listener"),
+\t\t\t\t}),
+\t\t\tonError(error, listener) {
+\t\t\t\tports.logger.error("Event listener failed", {
+\t\t\t\t\terror,
+\t\t\t\t\tlistenerName: listener.name,
+\t\t\t\t});
+\t\t\t},
+\t\t});
+
+\t\treturn {
+\t\t\tstop() {
+\t\t\t\tunregister();
+\t\t\t},
+\t\t};
+\t},
+});
+`;
+        const withProvider = next.replace(/\nexport const providers = \[/, `\n${providerDefinition}\nexport const providers = [`);
+        if (withProvider === next) {
+            throw new Error(`Could not find the exported providers array in ${providersFile}. Register ${listenerIndex.registryName} manually with registerListeners(...), or restore the generated providers file before running make listener.`);
+        }
+        next = withProvider;
+    }
+    const appended = appendToNamedArray(next, "providers", providerName);
+    if (appended.kind === "missing") {
+        throw new Error(`Could not find the exported providers array in ${providersFile}. Register ${listenerIndex.registryName} manually with registerListeners(...), or restore the generated providers file before running make listener.`);
+    }
+    if (appended.kind === "updated")
+        next = appended.source;
+    if (next === original)
+        return "skipped";
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return "updated";
+}
 export async function makeSchedule(options) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     const names = scheduleNames(options.name, {
@@ -982,29 +1099,65 @@ async function planOutboxDrainWiring(targetDir, config, options) {
     };
 }
 async function updateOutboxPortWiring(targetDir, config, options) {
-    const updated = new Set();
+    const changes = {
+        createdFiles: [],
+        updatedFiles: [],
+        skippedFiles: [],
+    };
     if (await updateOutboxPorts(targetDir, config, options)) {
-        updated.add(config.paths.ports);
+        changes.updatedFiles.push(config.paths.ports);
     }
     if (await updateOutboxInfrastructurePorts(targetDir, config, options)) {
-        updated.add(config.paths.infrastructurePorts);
+        changes.updatedFiles.push(config.paths.infrastructurePorts);
     }
     if (await updateOutboxDatabaseProvider(targetDir, config, options)) {
-        updated.add(path.join(infrastructureDir(config), "db/provider.ts"));
+        changes.updatedFiles.push(path.join(infrastructureDir(config), "db/provider.ts"));
     }
     if (await updateOutboxRepositoriesReturnType(targetDir, config, options)) {
-        updated.add(drizzleRepositoriesPath(config));
+        changes.updatedFiles.push(drizzleRepositoriesPath(config));
     }
-    return [...updated];
+    const schemaResult = await updateOutboxDrizzleSchema(targetDir, config, options);
+    if (schemaResult.result === "created") {
+        changes.createdFiles.push(schemaResult.path);
+    }
+    if (schemaResult.result === "updated") {
+        changes.updatedFiles.push(schemaResult.path);
+    }
+    if (schemaResult.result === "skipped") {
+        changes.skippedFiles.push(schemaResult.path);
+    }
+    if (schemaResult.canExport) {
+        const schemaIndexUpdated = await updateOutboxDrizzleSchemaIndex(targetDir, config, options);
+        if (schemaIndexUpdated) {
+            changes.updatedFiles.push(drizzleSchemaIndexPath(config));
+        }
+    }
+    return {
+        createdFiles: uniqueStrings(changes.createdFiles),
+        updatedFiles: uniqueStrings(changes.updatedFiles),
+        skippedFiles: uniqueStrings(changes.skippedFiles),
+    };
 }
 async function applyOutboxPortWiring(result, targetDir, config, options) {
-    const updatedFiles = await updateOutboxPortWiring(targetDir, config, options);
-    for (const file of updatedFiles) {
+    const changes = await updateOutboxPortWiring(targetDir, config, options);
+    for (const file of changes.createdFiles) {
+        if (!result.createdFiles.includes(file))
+            result.createdFiles.push(file);
+        if (!result.files.includes(file))
+            result.files.push(file);
+    }
+    for (const file of changes.updatedFiles) {
         if (!result.updatedFiles.includes(file))
             result.updatedFiles.push(file);
         if (!result.files.includes(file))
             result.files.push(file);
     }
+    for (const file of changes.skippedFiles) {
+        if (!result.skippedFiles.includes(file))
+            result.skippedFiles.push(file);
+        if (!result.files.includes(file))
+            result.files.push(file);
+    }
 }
 async function updateOutboxPorts(targetDir, config, options) {
     const filePath = path.join(targetDir, config.paths.ports);
@@ -1082,6 +1235,42 @@ async function updateOutboxRepositoriesReturnType(targetDir, config, options) {
         await writeFile(filePath, next);
     return true;
 }
+async function updateOutboxDrizzleSchema(targetDir, config, options) {
+    const indexPath = path.join(targetDir, drizzleSchemaIndexPath(config));
+    const schemaPath = outboxDrizzleSchemaFilePath(config);
+    const destination = path.join(targetDir, schemaPath);
+    if (!(await fileExists(indexPath))) {
+        return { path: schemaPath, canExport: false };
+    }
+    const database = await detectResourceDatabase(targetDir, config);
+    const content = outboxDrizzleSchemaFile(drizzleDialects[database]);
+    const existing = await readOptionalFile(destination);
+    if (existing === undefined) {
+        if (!options.dryRun) {
+            await mkdir(path.dirname(destination), { recursive: true });
+            await writeFile(destination, content);
+        }
+        return { path: schemaPath, result: "created", canExport: true };
+    }
+    if (existing === content ||
+        /\bexport\s+const\s+outboxMessages\b/.test(existing)) {
+        return { path: schemaPath, result: "skipped", canExport: true };
+    }
+    return { path: schemaPath, result: "skipped", canExport: false };
+}
+async function updateOutboxDrizzleSchemaIndex(targetDir, config, options) {
+    const filePath = path.join(targetDir, drizzleSchemaIndexPath(config));
+    if (!(await fileExists(filePath)))
+        return false;
+    const original = await readFile(filePath, "utf8");
+    const exportLine = 'export { outboxMessages } from "./outbox-messages";';
+    if (original.includes(exportLine))
+        return false;
+    const next = `${original.trimEnd()}\n${exportLine}\n`;
+    if (!options.dryRun)
+        await writeFile(filePath, next);
+    return true;
+}
 function drizzleOutboxPortFactoryName(database) {
     if (database === "postgres")
         return "createDrizzlePostgresOutboxPort";
@@ -1358,9 +1547,12 @@ export async function makeOutbox(options = {}) {
     createdFiles.push(...cronSecretResult.createdFiles);
     updatedFiles.push(...cronSecretResult.updatedFiles);
     skippedFiles.push(...cronSecretResult.skippedFiles);
-    updatedFiles.push(...(await updateOutboxPortWiring(targetDir, config, {
+    const outboxWiringResult = await updateOutboxPortWiring(targetDir, config, {
         dryRun: Boolean(options.dryRun),
-    })));
+    });
+    createdFiles.push(...outboxWiringResult.createdFiles);
+    updatedFiles.push(...outboxWiringResult.updatedFiles);
+    skippedFiles.push(...outboxWiringResult.skippedFiles);
     return {
         schemaVersion: 1,
         name: "outbox",
@@ -1374,6 +1566,8 @@ export async function makeOutbox(options = {}) {
             config.paths.infrastructurePorts,
             path.join(infrastructureDir(config), "db/provider.ts"),
             drizzleRepositoriesPath(config),
+            outboxDrizzleSchemaFilePath(config),
+            drizzleSchemaIndexPath(config),
         ],
         createdFiles: uniqueStrings(createdFiles),
         updatedFiles: uniqueStrings(updatedFiles),
@@ -3540,8 +3734,13 @@ function paymentsFiles(config, database) {
     ];
 }
 function featureUiComponentFiles(names, config) {
+    const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
     const componentPath = featureUiComponentFilePath(names, config);
     return [
+        {
+            path: clientQueriesPath,
+            content: featureUiClientQueriesFile(names, config),
+        },
         {
             path: componentPath,
             content: featureUiComponentFile(names, config),
@@ -3713,6 +3912,9 @@ function drizzleRepositoriesPath(config) {
 function drizzleResourceSchemaFilePath(names, config) {
     return path.join(infrastructureDir(config), "db", "schema", `${names.pluralKebab}.ts`);
 }
+function outboxDrizzleSchemaFilePath(config) {
+    return path.join(infrastructureDir(config), "db", "schema", "outbox-messages.ts");
+}
 function drizzleResourceRepositoryFilePath(names, config) {
     return path.join(infrastructureDir(config), names.pluralKebab, `drizzle-${names.singularKebab}-repository.ts`);
 }
@@ -3771,6 +3973,12 @@ function resourceFeatureDir(names, config) {
 function featureUiDir(names, config) {
     return path.join(resourceFeatureDir(names, config), "components");
 }
+function featureUiClientDir(names, config) {
+    return path.join(resourceFeatureDir(names, config), "client");
+}
+function featureUiClientQueriesFilePath(names, config) {
+    return path.join(featureUiClientDir(names, config), "queries.ts");
+}
 function featureUiComponentFilePath(names, config) {
     return path.join(featureUiDir(names, config), `${names.componentFileName}.tsx`);
 }
@@ -4460,7 +4668,7 @@ export type List${names.pluralPascal}Input = z.infer<
 }
 function listUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `list-${names.pluralKebab}.ts`);
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { normalizeCursorPage } from "@beignet/core/pagination";
 import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
@@ -4491,7 +4699,7 @@ ${options.tenant ? `\t\t\ttenantId,\n` : ""}		});
 }
 function createUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `create-${names.singularKebab}.ts`);
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
 	Create${names.singularPascal}InputSchema,
@@ -4514,7 +4722,7 @@ ${options.events ? `\n\t\tawait ctx.ports.eventBus.publish(${names.singularPasca
 }
 function getUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `get-${names.singularKebab}.ts`);
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
 import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 import {
@@ -4540,7 +4748,7 @@ ${options.tenant ? `\t\tconst tenantId = ctx.tenant?.id;\n\t\tif (!tenantId) {\n
 }
 function updateUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `update-${names.singularKebab}.ts`);
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
 import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 ${options.events ? `import { ${names.singularPascal}Updated } from "../domain/events";\n` : ""}import {
@@ -4580,7 +4788,7 @@ ${options.events ? `\n\t\tawait ctx.ports.eventBus.publish(${names.singularPasca
 }
 function deleteUseCaseFile(names, config, options) {
     const filePath = path.join(resourceUseCaseDir(names, config), `delete-${names.singularKebab}.ts`);
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { z } from "zod";
 import { appError } from "${relativeModule(filePath, resourceSharedErrorsPath(config))}";
 import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
@@ -4673,7 +4881,7 @@ function inMemoryRepositoryFile(names, config, mode, options) {
 			${names.pluralCamel}.set(id, { ...existing, deletedAt: now, updatedAt: now });
 			return true;`
         : `${options.tenant ? `\t\t\tconst existing = ${names.pluralCamel}.get(id);\n\t\t\tif (existing?.tenantId !== filter.tenantId) return false;\n` : ""}			return ${names.pluralCamel}.delete(id);`;
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { cursorPageResult } from "@beignet/core/pagination";
 import type { ${names.singularPascal}Repository } from "${aliasModule(repositoryPortPath)}";
 import { encode${names.singularPascal}Cursor } from "${aliasModule(resourceSchemaFilePath(names, config))}";
@@ -4792,6 +5000,76 @@ ${options.tenant ? `\ttenantId: ${dialect.idColumn("tenant_id")}.notNull(),\n` :
 ${options.softDelete ? `\tdeletedAt: ${dialect.timestampColumn("deleted_at")},\n` : ""}});
 `;
 }
+function outboxDrizzleSchemaFile(dialect) {
+    if (dialect.subpath === "mysql") {
+        return `import { index, int, longtext, mysqlTable, varchar } from "drizzle-orm/mysql-core";
+
+export const outboxMessages = mysqlTable(
+\t"outbox_messages",
+\t{
+\t\tid: varchar("id", { length: 255 }).primaryKey(),
+\t\tkind: varchar("kind", { length: 32 }).notNull(),
+\t\tname: varchar("name", { length: 255 }).notNull(),
+\t\tpayloadJson: longtext("payload_json").notNull(),
+\t\tstatus: varchar("status", { length: 32 }).notNull(),
+\t\tattempts: int("attempts").notNull().default(0),
+\t\tmaxAttempts: int("max_attempts").notNull().default(3),
+\t\tavailableAt: varchar("available_at", { length: 32 }).notNull(),
+\t\tclaimedAt: varchar("claimed_at", { length: 32 }),
+\t\tlockedUntil: varchar("locked_until", { length: 32 }),
+\t\tclaimToken: varchar("claim_token", { length: 64 }),
+\t\tdeliveredAt: varchar("delivered_at", { length: 32 }),
+\t\tlastErrorJson: longtext("last_error_json"),
+\t\tcreatedAt: varchar("created_at", { length: 32 }).notNull(),
+\t\tupdatedAt: varchar("updated_at", { length: 32 }).notNull(),
+\t},
+\t(table) => ({
+\t\tavailableIdx: index("outbox_messages_available_idx").on(
+\t\t\ttable.status,
+\t\t\ttable.availableAt,
+\t\t),
+\t\tlockedIdx: index("outbox_messages_locked_idx").on(
+\t\t\ttable.status,
+\t\t\ttable.lockedUntil,
+\t\t),
+\t}),
+);
+`;
+    }
+    return `import { index, integer, ${dialect.tableFunction}, text } from "${dialect.columnModule}";
+
+export const outboxMessages = ${dialect.tableFunction}(
+\t"outbox_messages",
+\t{
+\t\tid: text("id").primaryKey(),
+\t\tkind: text("kind").notNull(),
+\t\tname: text("name").notNull(),
+\t\tpayloadJson: text("payload_json").notNull(),
+\t\tstatus: text("status").notNull(),
+\t\tattempts: integer("attempts").notNull().default(0),
+\t\tmaxAttempts: integer("max_attempts").notNull().default(3),
+\t\tavailableAt: text("available_at").notNull(),
+\t\tclaimedAt: text("claimed_at"),
+\t\tlockedUntil: text("locked_until"),
+\t\tclaimToken: text("claim_token"),
+\t\tdeliveredAt: text("delivered_at"),
+\t\tlastErrorJson: text("last_error_json"),
+\t\tcreatedAt: text("created_at").notNull(),
+\t\tupdatedAt: text("updated_at").notNull(),
+\t},
+\t(table) => ({
+\t\tavailableIdx: index("outbox_messages_available_idx").on(
+\t\t\ttable.status,
+\t\t\ttable.availableAt,
+\t\t),
+\t\tlockedIdx: index("outbox_messages_locked_idx").on(
+\t\t\ttable.status,
+\t\t\ttable.lockedUntil,
+\t\t),
+\t}),
+);
+`;
+}
 function drizzleResourceWhere(names, options, predicates) {
     const allPredicates = [
         ...predicates,
@@ -4961,7 +5239,7 @@ ${options.softDelete ? `\t\t\tconst now = new Date().toISOString();\n\t\t\tconst
 			return affectedRows(result) > 0;
 		},
 `;
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { cursorPageResult } from "@beignet/core/pagination";
 import type { ${dialect.dbTypeName} } from "@beignet/provider-db-drizzle/${dialect.subpath}";
 import { ${drizzleImports.join(", ")} } from "drizzle-orm";
@@ -5182,7 +5460,7 @@ export const ${names.pluralCamel}Contracts = [list${names.pluralPascal}];
 `;
 }
 function standaloneUseCaseFile(names, config, filePath) {
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { z } from "zod";
 import { useCase } from "${relativeModule(filePath, config.paths.useCaseBuilder)}";
 
@@ -6950,28 +7228,30 @@ export const { POST } = createPaymentWebhookRoute({
 `;
 }
 function featureUiComponentFile(names, config) {
+    const componentPath = featureUiComponentFilePath(names, config);
+    const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
     return `"use client";
 
 import { contractErrorMessage } from "@beignet/core/client";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useState } from "react";
-import { rq } from "${aliasModule(clientIndexPath(config))}";
-import { create${names.singularPascal}, list${names.pluralPascal} } from "${aliasModule(resourceContractFilePath(names, config))}";
+import {
+\tcreate${names.singularPascal}MutationOptions,
+\tinvalidate${names.pluralPascal},
+\tlist${names.pluralPascal}QueryOptions,
+} from "${relativeModule(componentPath, clientQueriesPath)}";
 
 export function ${names.componentExportName}() {
 \tconst [name, setName] = useState("");
 \tconst queryClient = useQueryClient();
-\tconst ${names.pluralCamel}Query = useQuery(
-\t\trq(list${names.pluralPascal}).queryOptions({ query: {} }),
-\t);
-\tconst create${names.singularPascal}Mutation = useMutation(
-\t\trq(create${names.singularPascal}).mutationOptions({
-\t\t\tonSuccess: async () => {
-\t\t\t\tsetName("");
-\t\t\t\tawait rq(list${names.pluralPascal}).invalidate(queryClient);
-\t\t\t},
-\t\t}),
-\t);
+\tconst ${names.pluralCamel}Query = useQuery(list${names.pluralPascal}QueryOptions());
+\tconst create${names.singularPascal}Mutation = useMutation({
+\t\t...create${names.singularPascal}MutationOptions(),
+\t\tonSuccess: async () => {
+\t\t\tsetName("");
+\t\t\tawait invalidate${names.pluralPascal}(queryClient);
+\t\t},
+\t});
 
 \treturn (
 \t\t<section className="${names.pluralKebab}-panel">
@@ -7038,6 +7318,29 @@ export function ${names.componentExportName}() {
 }
 `;
 }
+function featureUiClientQueriesFile(names, config) {
+    const clientQueriesPath = featureUiClientQueriesFilePath(names, config);
+    const contractsPath = resourceContractFilePath(names, config);
+    return `import type { QueryClient } from "@tanstack/react-query";
+import { rq } from "${aliasModule(clientIndexPath(config))}";
+import {
+\tcreate${names.singularPascal},
+\tlist${names.pluralPascal},
+} from "${relativeModule(clientQueriesPath, contractsPath)}";
+
+export function list${names.pluralPascal}QueryOptions() {
+\treturn rq(list${names.pluralPascal}).queryOptions({ query: {} });
+}
+
+export function create${names.singularPascal}MutationOptions() {
+\treturn rq(create${names.singularPascal}).mutationOptions();
+}
+
+export function invalidate${names.pluralPascal}(queryClient: QueryClient) {
+\treturn rq(list${names.pluralPascal}).invalidate(queryClient);
+}
+`;
+}
 function scheduleRouteFile(names, config) {
     return `import { createScheduleRoute } from "@beignet/next";
 import { ${names.scheduleExportName} } from "${aliasModule(scheduleFilePath(names, config))}";
@@ -7069,7 +7372,7 @@ function routeGroupFile(names, config, mode, _options) {
     const routeFilePath = path.join(config.paths.features, names.pluralKebab, "routes.ts");
     const contractsPath = resourceContractFilePath(names, config);
     const useCasesPath = resourceUseCaseIndexPath(names, config);
-    return `import type { beignetServerOnly } from "@beignet/core/server-only";
+    return `import "@beignet/core/server-only";
 import { defineRouteGroup } from "@beignet/next";
 import type { AppContext } from "${relativeModule(routeFilePath, config.paths.appContext)}";
 import {
@@ -7093,11 +7396,11 @@ ${mode === "resource" ? `		{ contract: get${names.singularPascal}, useCase: get$
 function testFile(names, config, mode, options) {
     const repositoryPath = path.join(path.dirname(config.paths.infrastructurePorts), names.pluralKebab, `in-memory-${names.singularKebab}-repository.ts`);
     const serverContextPath = path.join(path.dirname(config.paths.server), "context.ts");
-    const requestTarget = options.tenant ? "requester" : "app";
+    const requestTarget = "app";
     return `import { describe, expect, it } from "bun:test";
 import { createUseCaseTester } from "@beignet/core/application";
 ${mode === "resource" ? `import { isAppError } from "@beignet/core/errors";\n` : ""}import { defineRoutes } from "@beignet/web";
-import { createTestApp${options.tenant ? ", createTestRequester" : ""} } from "@beignet/web/testing";
+import { createTestApp } from "@beignet/web/testing";
 import { createInMemoryDevtools } from "@beignet/devtools";
 import { createTestContextFactory, createTestPorts } from "@beignet/core/testing";
 import { ${options.auth ? "createTestUserActor" : "createTestAnonymousActor"}${options.tenant ? ", createTestTenant" : ""} } from "@beignet/core/ports/testing";
@@ -7145,13 +7448,15 @@ ${options.tenant ? `\t\t\t{\n\t\t\t\tid: "00000000-0000-4000-8000-000000000104",
 			base: appPorts,
 			overrides: {
 				${names.pluralCamel},
-${options.auth
+${options.auth || options.tenant
         ? `\t\t\t\tauth: {
 					getSession: async () => ({
-						user: { id: "user_test", name: "Test User" },
+						user: { id: "user_test", name: "Test User"${options.tenant ? `, tenantId: "tenant_test"` : ""} },
+${options.tenant ? `\t\t\t\t\t\tsession: { tenantId: "tenant_test" },\n` : ""}
 					}),
 				},
-				gate: appPorts.gate,\n`
+${options.auth ? `\t\t\t\tgate: appPorts.gate,\n` : ""}
+`
         : `\t\t\t\tauth: {
 					getSession: async () => null,
 				},\n`}				devtools: createInMemoryDevtools(),
@@ -7298,7 +7603,6 @@ ${mode === "resource"
 			routes: defineRoutes<AppContext>([${names.singularCamel}Routes]),
 			context: appContext,
 		});
-${options.tenant ? `\t\tconst requester = createTestRequester(app, {\n\t\t\theaders: { "x-tenant-id": "tenant_test" },\n\t\t});\n` : ""}
 		const createdViaRoute = await ${requestTarget}.request(create${names.singularPascal}, {
 			body: { name: "Second ${names.singularPascal}" },
 		});