domain-driver 0.3.1 → 0.4.1

package/dist/commands/target.js

@@ -3,11 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseTarget = parseTarget;
 exports.parseFeatureTarget = parseFeatureTarget;
 const naming_1 = require("../utils/naming");
-const NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+const NAME_PATTERN = /^[A-Z][A-Za-z0-9]*$/;
+const HOOK_NAME_PATTERN = /^use[A-Z]/;
 function validateName(name) {
-    if (!NAME_PATTERN.test(name)) {
-        throw new Error(`Name "${name}" must be letters and digits only, for example User.`);
+    if (NAME_PATTERN.test(name))
+        return;
+    if (HOOK_NAME_PATTERN.test(name)) {
+        throw new Error(`Name "${name}" is a hook name. Pass the entity instead, for example ${name.slice(3)}.`);
     }
+    throw new Error(`Name "${name}" must be PascalCase, for example User.`);
 }
 function parseTarget(value) {
     const parts = value.split('/');

package/dist/init/content.js

@@ -15,6 +15,7 @@ const AGENTS_LINES = [
     'Rules the generated code follows, and that new code must keep:',
     '',
     '- One file per action per layer. `findActiveUsers` gets `FindActiveUsers.service.ts`, `FindActiveUsers.repository.ts`, and `FindActiveUsers.controller.ts`. It never goes inside `ShowUser.service.ts` or `ListUser.service.ts`.',
+    '- Hooks are one file per action too: `<Action><Entity>.hook.ts` exporting `use<Action><Entity>` (for example `useListUser`, `useCreateUser`). There is no combined `use<Entity>.ts`.',
     '- The chain is controller or hook, then service, then repository. Business logic lives in services. Data access lives in repositories. Controllers validate input and call one service.',
     '- Feature folders are kebab-case (`coffee-type`). Entity, action, and class names are PascalCase (`CoffeeType`, `FindActiveUsers`).',
     '- Generated repositories throw until you wire them to your data source. Generated controllers on Node need a line in `<feature>.routes.ts`, and on Nest need registering in `<feature>.module.ts`; the tool prints the exact line.',
@@ -34,7 +35,8 @@ const SKILL_LINES = [
     '',
     '## Detect the stack',
     '',
-    'The tool reads `package.json` and prints `Stack: <stack> (detected)` before every command. Stacks: `next-fullstack`, `next-frontend`, `react`, `node` (Express, Fastify, Hono, or none), `nest`. Override with `--stack <name>` if detection is wrong.',
+    'The tool reads `package.json` and prints `Stack: <stack> (detected), root: <dir>` before every command. Stacks: `next-fullstack`, `next-frontend`, `react`, `node` (Express, Fastify, Hono, or none), `nest`, `tanstack-start`. Override with `--stack <name>` if detection is wrong.',
+    'Where features are written can be overridden too: `--root <dir>` for one command, or a `domainDriver.featureRoot` key in `package.json` for the project. Read the root off the stack line rather than assuming the convention.',
     '',
     '## Commands',
     '',
@@ -49,10 +51,12 @@ const SKILL_LINES = [
     '| Five controllers or Next route handlers | `npx domain-driver make:controller users/User` |',
     '| A bespoke operation | `npx domain-driver make:action users/User findActiveUsers` |',
     '| Bespoke operation with a request body | `npx domain-driver make:action users/User archiveUser --with-input --returns one` |',
-    '| Component, container, hook | `npx domain-driver make:component users/UserCard`, `make:container users/UserContainer`, `make:hook users/useUser` |',
+    '| Component, container, hook | `npx domain-driver make:component users/UserCard`, `make:container users/UserContainer`, `make:hook users/User` |',
     '| Refresh this guidance | `npx domain-driver init` |',
     '',
-    'On `next-fullstack`, `make:service` and `make:repository` take `--side client|server|both` (default both).',
+    'On `next-fullstack` and `tanstack-start`, `make:service` and `make:repository` take `--side client|server|both` (default both).',
+    '',
+    'Hooks are one file per action — `<Action><Entity>.hook.ts` exporting `use<Action><Entity>` — never a combined `use<Entity>.ts`. On `tanstack-start` they are TanStack Query hooks backed by a generated `<feature>.keys.ts`; elsewhere they are plain React state.',
     '',
     '## Rules',
     '',
@@ -67,7 +71,8 @@ const SKILL_LINES = [
     '',
     '- Next.js: `app/<feature>` or `src/app/<feature>`; route handlers under `app/api/<feature>`.',
     '- React and Node: `src/features/<feature>` or `features/<feature>`.',
-    '- Nest: `src/<feature>` with a `<feature>.module.ts`.',
+    '- Nest: `src/features/<feature>` when `src/features` exists, otherwise `src/<feature>`, with a `<feature>.module.ts`.',
+    '- TanStack Start: `src/routes/<feature>` or `routes/<feature>`; every layer folder is prefixed with `-` so the router ignores it, and the entry file is `index.tsx`, not `page.tsx`.',
 ];
 exports.AGENTS_SECTION = AGENTS_LINES.join('\n');
 exports.SKILL_CONTENT = `${SKILL_LINES.join('\n')}\n`;

package/dist/stack/detect.js

@@ -41,22 +41,30 @@ const path = __importStar(require("path"));
 const fs_1 = require("../utils/fs");
 const types_1 = require("./types");
 const API_DIRS = ['app/api', 'src/app/api', 'pages/api', 'src/pages/api'];
+const ROOT_LABELS = Object.freeze({
+    detected: '',
+    flag: ' (--root)',
+    config: ' (package.json)',
+});
 let cached;
 function resetStackCache() {
     cached = undefined;
 }
-function detectStack(override) {
+function detectStack(override, rootOverride) {
     if (cached)
         return cached;
     const cwd = process.cwd();
     const overridden = override !== undefined;
-    const deps = readDependencies(cwd, overridden);
+    const pkg = readPackageJson(cwd, overridden);
+    const deps = dependencyNames(pkg);
     const stack = overridden ? parseOverride(override) : inferStack(cwd, deps);
+    const root = resolveRoot(cwd, stack, pkg, rootOverride);
     const result = Object.freeze({
         stack,
         source: overridden ? 'override' : 'detected',
         httpFramework: stack === 'node' ? detectHttpFramework(deps) : null,
-        featureRoot: resolveFeatureRoot(cwd, stack),
+        featureRoot: root.featureRoot,
+        featureRootSource: root.source,
         hasNestjsZod: deps.has('nestjs-zod'),
     });
     cached = result;
@@ -64,18 +72,19 @@ function detectStack(override) {
 }
 function describeStack(stack) {
     const base = `Stack: ${stack.stack} (${stack.source})`;
-    if (stack.stack !== 'node')
-        return base;
-    return `${base}, http: ${stack.httpFramework ?? 'none'}`;
+    const http = stack.stack === 'node' ? `, http: ${stack.httpFramework ?? 'none'}` : '';
+    return `${base}${http}, root: ${stack.featureRoot}${ROOT_LABELS[stack.featureRootSource]}`;
 }
-function readDependencies(cwd, optional) {
+function readPackageJson(cwd, optional) {
     const pkgPath = path.join(cwd, 'package.json');
     if (!fs.existsSync(pkgPath)) {
         if (optional)
-            return new Set();
+            return {};
         throw new Error(`No package.json found in ${cwd}. Run domain-driver from your project root, or pass --stack <name>.`);
     }
-    const pkg = parsePackageJson(pkgPath);
+    return parsePackageJson(pkgPath);
+}
+function dependencyNames(pkg) {
     return new Set([
         ...Object.keys(pkg.dependencies ?? {}),
         ...Object.keys(pkg.devDependencies ?? {}),
@@ -99,6 +108,8 @@ function parseOverride(value) {
 function inferStack(cwd, deps) {
     if (deps.has('@nestjs/core'))
         return 'nest';
+    if (deps.has('@tanstack/react-start'))
+        return 'tanstack-start';
     if (deps.has('next'))
         return hasApiDir(cwd) ? 'next-fullstack' : 'next-frontend';
     if (deps.has('react'))
@@ -111,7 +122,38 @@ function hasApiDir(cwd) {
 function detectHttpFramework(deps) {
     return types_1.HTTP_FRAMEWORKS.find((name) => deps.has(name)) ?? null;
 }
-function resolveFeatureRoot(cwd, stack) {
+function resolveRoot(cwd, stack, pkg, flag) {
+    if (flag !== undefined) {
+        return { featureRoot: validateRoot(flag, '--root'), source: 'flag' };
+    }
+    const configured = configuredRoot(pkg);
+    if (configured !== null) {
+        return { featureRoot: configured, source: 'config' };
+    }
+    return { featureRoot: conventionalRoot(cwd, stack), source: 'detected' };
+}
+function configuredRoot(pkg) {
+    const value = pkg.domainDriver?.featureRoot;
+    if (value === undefined)
+        return null;
+    if (typeof value !== 'string') {
+        throw new Error('package.json "domainDriver.featureRoot" must be a string, for example "src/features".');
+    }
+    return validateRoot(value, 'package.json');
+}
+/**
+ * The root becomes a filesystem path under the project, so an absolute path or any
+ * `..` segment would write outside it. Both are rejected rather than normalised away.
+ */
+function validateRoot(value, source) {
+    const normalized = value.replace(/\\/g, '/').replace(/\/+$/, '');
+    const escapes = normalized === '' || path.isAbsolute(value) || normalized.split('/').includes('..');
+    if (escapes) {
+        throw new Error(`Feature root "${value}" from ${source} must be a relative path inside the project, for example src/features.`);
+    }
+    return normalized;
+}
+function conventionalRoot(cwd, stack) {
     switch (stack) {
         case 'next-fullstack':
         case 'next-frontend':
@@ -120,6 +162,10 @@ function resolveFeatureRoot(cwd, stack) {
         case 'node':
             return (0, fs_1.isDirectory)(path.join(cwd, 'src')) ? 'src/features' : 'features';
         case 'nest':
-            return 'src';
+            return (0, fs_1.isDirectory)(path.join(cwd, 'src', 'features')) ? 'src/features' : 'src';
+        case 'tanstack-start':
+            if ((0, fs_1.isDirectory)(path.join(cwd, 'src', 'routes')))
+                return 'src/routes';
+            return (0, fs_1.isDirectory)(path.join(cwd, 'routes')) ? 'routes' : 'src/routes';
     }
 }

package/dist/stack/profiles/nest.js

@@ -15,4 +15,5 @@ exports.nest = Object.freeze({
     },
     clientDirective: false,
     serverComponents: false,
+    queryHooks: false,
 });

package/dist/stack/profiles/next-frontend.js

@@ -25,4 +25,5 @@ exports.nextFrontend = Object.freeze({
     },
     clientDirective: true,
     serverComponents: true,
+    queryHooks: false,
 });

package/dist/stack/profiles/next-fullstack.js

@@ -41,4 +41,5 @@ exports.nextFullstack = Object.freeze({
     },
     clientDirective: true,
     serverComponents: true,
+    queryHooks: false,
 });

package/dist/stack/profiles/node.js

@@ -14,4 +14,5 @@ exports.node = Object.freeze({
     },
     clientDirective: false,
     serverComponents: false,
+    queryHooks: false,
 });

package/dist/stack/profiles/react.js

@@ -16,4 +16,5 @@ exports.react = Object.freeze({
     },
     clientDirective: false,
     serverComponents: false,
+    queryHooks: false,
 });

package/dist/stack/profiles/tanstack-start.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tanstackStart = void 0;
+exports.tanstackStart = Object.freeze({
+    name: 'tanstack-start',
+    folders: [
+        '-components',
+        '-containers',
+        '-hooks',
+        '-client/services',
+        '-client/repositories',
+        '-server/functions',
+        '-server/services',
+        '-server/repositories',
+        '-schemas',
+        '-types',
+    ],
+    layers: [
+        'page',
+        'component',
+        'container',
+        'hook',
+        'clientService',
+        'clientRepository',
+        'serverService',
+        'serverRepository',
+        'controller',
+        'schema',
+        'types',
+    ],
+    layerDirs: {
+        component: '-components',
+        container: '-containers',
+        hook: '-hooks',
+        clientService: '-client/services',
+        clientRepository: '-client/repositories',
+        serverService: '-server/services',
+        serverRepository: '-server/repositories',
+        controller: '-server/functions',
+        schema: '-schemas',
+        types: '-types',
+    },
+    clientDirective: false,
+    serverComponents: false,
+    queryHooks: true,
+});

package/dist/stack/registry.js

@@ -11,12 +11,14 @@ const next_frontend_1 = require("./profiles/next-frontend");
 const react_1 = require("./profiles/react");
 const node_1 = require("./profiles/node");
 const nest_1 = require("./profiles/nest");
+const tanstack_start_1 = require("./profiles/tanstack-start");
 const PROFILES = Object.freeze({
     'next-fullstack': next_fullstack_1.nextFullstack,
     'next-frontend': next_frontend_1.nextFrontend,
     react: react_1.react,
     node: node_1.node,
     nest: nest_1.nest,
+    'tanstack-start': tanstack_start_1.tanstackStart,
 });
 const LAYER_COMMANDS = Object.freeze({
     component: 'make:component',
@@ -45,7 +47,8 @@ function layerDir(profile, layer) {
     return dir;
 }
 function componentDir(profile, type) {
-    return profile.serverComponents ? `components/${type}` : 'components';
+    const base = layerDir(profile, 'component');
+    return profile.serverComponents ? `${base}/${type}` : base;
 }
 function availableCommands(profile) {
     const commands = profile.layers

package/dist/stack/types.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LAYERS = exports.HTTP_FRAMEWORKS = exports.STACK_NAMES = void 0;
 exports.isStackName = isStackName;
-exports.STACK_NAMES = ['next-fullstack', 'next-frontend', 'react', 'node', 'nest'];
+exports.STACK_NAMES = ['next-fullstack', 'next-frontend', 'react', 'node', 'nest', 'tanstack-start'];
 exports.HTTP_FRAMEWORKS = ['express', 'fastify', 'hono'];
 exports.LAYERS = [
     'page',

package/dist/templates/actions.js

@@ -5,6 +5,7 @@ exports.actionCase = actionCase;
 exports.standardAction = standardAction;
 exports.standardActions = standardActions;
 exports.customAction = customAction;
+exports.isQueryAction = isQueryAction;
 const naming_1 = require("../utils/naming");
 exports.ACTIONS = ['List', 'Show', 'Create', 'Update', 'Delete'];
 exports.WRITE_ACTIONS = ['Create', 'Update'];
@@ -66,3 +67,14 @@ function customAction(entity, actionName, options) {
         failure: `Failed to ${camel} ${entity}`,
     });
 }
+/**
+ * Whether a hook renders as a query (auto-fetches, returns data) rather than a mutation
+ * (triggered imperatively). `spec.method === 'get'` alone is not enough: a custom action
+ * declared `--returns void` is also a GET (no input forces GET regardless of return kind),
+ * but it has no payload worth polling for and must not auto-fire on mount. `usesEntityType`
+ * is false exactly when the action returns void, so requiring it here routes that case to
+ * the mutation branch instead.
+ */
+function isQueryAction(spec) {
+    return spec.method === 'get' && spec.usesEntityType;
+}

package/dist/templates/controllers/server-fn.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderServerFn = renderServerFn;
+const naming_1 = require("../../utils/naming");
+function inputFor(spec) {
+    if (spec.schema !== null && spec.usesId) {
+        return {
+            validator: `z.object({ id: z.string(), data: ${spec.schema}Schema })`,
+            call: 'data.id, data.data',
+            handlerArg: '{ data }',
+            needsZod: true,
+        };
+    }
+    if (spec.schema !== null) {
+        return { validator: `${spec.schema}Schema`, call: 'data', handlerArg: '{ data }', needsZod: false };
+    }
+    if (spec.usesId) {
+        return { validator: 'z.string()', call: 'data', handlerArg: '{ data }', needsZod: true };
+    }
+    return { validator: null, call: '', handlerArg: '', needsZod: false };
+}
+function renderServerFn(ctx, spec, entity, fromFile) {
+    const { validator, call, handlerArg, needsZod } = inputFor(spec);
+    const method = spec.method === 'get' ? 'GET' : 'POST';
+    const servicePath = ctx.importLayer(fromFile, 'serverService', `${spec.name}.service`);
+    const imports = ["import { createServerFn } from '@tanstack/react-start';"];
+    if (needsZod)
+        imports.push("import { z } from 'zod';");
+    if (spec.schema !== null) {
+        const schemaPath = ctx.importLayer(fromFile, 'schema', `${spec.schema}.schema`);
+        imports.push(`import { ${spec.schema}Schema } from '${schemaPath}';`);
+    }
+    imports.push(`import { ${spec.name}Service } from '${servicePath}';`);
+    const validatorLine = validator === null ? '' : `\n  .validator(${validator})`;
+    return `${imports.join('\n')}
+
+const service = new ${spec.name}Service();
+
+export const ${(0, naming_1.lowerFirst)(spec.name)} = createServerFn({ method: '${method}' })${validatorLine}
+  .handler(async (${handlerArg}) => service.handle(${call}));
+`;
+}

package/dist/templates/frontend/container.js

@@ -4,21 +4,25 @@ exports.renderContainer = renderContainer;
 const registry_1 = require("../../stack/registry");
 function renderContainer(ctx, containerName, entity, fromFile) {
     const header = ctx.profile.clientDirective ? "'use client';\n\n" : '';
-    const hookName = `use${entity}`;
-    const hookPath = ctx.importLayer(fromFile, 'hook', hookName);
+    const hookName = `useList${entity}`;
+    const hookPath = ctx.importLayer(fromFile, 'hook', `List${entity}.hook`);
     const componentPath = ctx.importFrom(fromFile, `${(0, registry_1.componentDir)(ctx.profile, 'client')}/${entity}`);
+    const query = ctx.profile.queryHooks;
+    const loadingField = query ? 'isPending' : 'loading';
+    const errorExpression = query ? '{error.message}' : '{error}';
+    const items = query ? '(data ?? [])' : 'data';
     return `${header}import { ${hookName} } from '${hookPath}';
 import ${entity} from '${componentPath}';
 
 export default function ${containerName}() {
-  const { items, loading, error } = ${hookName}();
+  const { data, ${loadingField}, error } = ${hookName}();
 
-  if (loading) return <div>Loading...</div>;
-  if (error) return <div>Error: {error}</div>;
+  if (${loadingField}) return <div>Loading...</div>;
+  if (error) return <div>Error: ${errorExpression}</div>;
 
   return (
     <div>
-      {items.map((item) => (
+      {${items}.map((item) => (
         <${entity} key={item.id} {...item} />
       ))}
     </div>

package/dist/templates/frontend/hook.js

@@ -1,109 +1,93 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderHook = renderHook;
+const naming_1 = require("../../utils/naming");
 const actions_1 = require("../actions");
-function serviceImports(ctx, fromFile, entity) {
-    return actions_1.ACTIONS.map((action) => {
-        const servicePath = ctx.importLayer(fromFile, 'clientService', `${action}${entity}.service`);
-        return `import { ${action}${entity}Service } from '${servicePath}';`;
-    }).join('\n');
+const signatures_1 = require("../signatures");
+function payloadType(spec) {
+    return spec.returns.replace(/^Promise<(.*)>$/, '$1');
 }
-function serviceInstances(entity) {
-    return actions_1.ACTIONS.map((action) => `const ${action.toLowerCase()}Service = new ${action}${entity}Service();`).join('\n');
-}
-function renderHook(ctx, hookName, entity, fromFile) {
-    const header = ctx.profile.clientDirective ? "'use client';\n\n" : '';
-    const typePath = ctx.importLayer(fromFile, 'types', `${entity}.types`);
-    const createPath = ctx.importLayer(fromFile, 'schema', `Create${entity}.schema`);
-    const updatePath = ctx.importLayer(fromFile, 'schema', `Update${entity}.schema`);
-    return `${header}import { useState, useEffect, useCallback } from 'react';
-import { ${entity} } from '${typePath}';
-${serviceImports(ctx, fromFile, entity)}
-import { Create${entity} } from '${createPath}';
-import { Update${entity} } from '${updatePath}';
-
-${serviceInstances(entity)}
+function header(ctx, spec, entity, fromFile, hooks) {
+    const directive = ctx.profile.clientDirective ? "'use client';\n\n" : '';
+    const servicePath = ctx.importLayer(fromFile, 'clientService', `${spec.name}.service`);
+    const domain = (0, signatures_1.domainImports)(ctx, fromFile, spec, entity);
+    return `${directive}import { ${hooks} } from 'react';
+${domain.join('\n')}${domain.length > 0 ? '\n' : ''}import { ${spec.name}Service } from '${servicePath}';
 
-export function ${hookName}() {
-  const [items, setItems] = useState<${entity}[]>([]);
-  const [selected, setSelected] = useState<${entity} | null>(null);
+const service = new ${spec.name}Service();
+`;
+}
+function renderQuery(ctx, spec, entity, fromFile) {
+    const type = payloadType(spec);
+    const isList = type.endsWith('[]');
+    const stateType = isList ? type : `${type} | null`;
+    const initial = isList ? '[]' : 'null';
+    const deps = spec.usesId ? '[id]' : '[]';
+    return `${header(ctx, spec, entity, fromFile, 'useState, useEffect, useCallback')}
+export function use${spec.name}(${spec.params}) {
+  const [data, setData] = useState<${stateType}>(${initial});
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
-  const fetchAll = useCallback(async () => {
-    setLoading(true);
-    setError(null);
-    try {
-      const data = await listService.handle();
-      setItems(data);
-    } catch (err: unknown) {
-      setError(err instanceof Error ? err.message : 'Failed to fetch');
-    } finally {
-      setLoading(false);
-    }
-  }, []);
-
-  const fetchOne = useCallback(async (id: string) => {
+  const refetch = useCallback(async () => {
     setLoading(true);
     setError(null);
     try {
-      const data = await showService.handle(id);
-      setSelected(data);
+      setData(await service.handle(${spec.args}));
     } catch (err: unknown) {
-      setError(err instanceof Error ? err.message : 'Failed to fetch');
+      setError(err instanceof Error ? err.message : '${spec.failure}');
     } finally {
       setLoading(false);
     }
-  }, []);
+  }, ${deps});
 
-  const create = useCallback(async (data: Create${entity}) => {
-    setLoading(true);
-    setError(null);
-    try {
-      const created = await createService.handle(data);
-      setItems((prev) => [...prev, created]);
-      return created;
-    } catch (err: unknown) {
-      setError(err instanceof Error ? err.message : 'Failed to create');
-      return null;
-    } finally {
-      setLoading(false);
-    }
-  }, []);
+  useEffect(() => {
+    void refetch();
+  }, [refetch]);
 
-  const update = useCallback(async (id: string, data: Update${entity}) => {
-    setLoading(true);
-    setError(null);
-    try {
-      const updated = await updateService.handle(id, data);
-      setItems((prev) => prev.map((item) => (item.id === id ? updated : item)));
-      return updated;
-    } catch (err: unknown) {
-      setError(err instanceof Error ? err.message : 'Failed to update');
-      return null;
-    } finally {
-      setLoading(false);
-    }
-  }, []);
+  return { data, loading, error, refetch };
+}
+`;
+}
+function renderMutation(ctx, spec, entity, fromFile) {
+    const callable = (0, naming_1.lowerFirst)(spec.name);
+    const returnsValue = spec.usesEntityType;
+    const type = payloadType(spec);
+    const callbackType = returnsValue ? `(result: ${type}) => void` : '() => void';
+    const body = returnsValue
+        ? `      const result = await service.handle(${spec.args});
+      onSuccess?.(result);
+      return result;`
+        : `      await service.handle(${spec.args});
+      onSuccess?.();`;
+    const failure = returnsValue
+        ? `      setError(err instanceof Error ? err.message : '${spec.failure}');
+      return null;`
+        : `      setError(err instanceof Error ? err.message : '${spec.failure}');`;
+    return `${header(ctx, spec, entity, fromFile, 'useState, useCallback')}
+export function use${spec.name}(options: { onSuccess?: ${callbackType} } = {}) {
+  const { onSuccess } = options;
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
 
-  const remove = useCallback(async (id: string) => {
+  const ${callable} = useCallback(async (${spec.params}) => {
     setLoading(true);
     setError(null);
     try {
-      await deleteService.handle(id);
-      setItems((prev) => prev.filter((item) => item.id !== id));
+${body}
     } catch (err: unknown) {
-      setError(err instanceof Error ? err.message : 'Failed to delete');
+${failure}
     } finally {
       setLoading(false);
     }
-  }, []);
-
-  useEffect(() => {
-    fetchAll();
-  }, [fetchAll]);
+  }, [onSuccess]);
 
-  return { items, selected, loading, error, fetchAll, fetchOne, create, update, remove };
+  return { ${callable}, loading, error };
 }
 `;
 }
+function renderHook(ctx, spec, entity, fromFile) {
+    return (0, actions_1.isQueryAction)(spec)
+        ? renderQuery(ctx, spec, entity, fromFile)
+        : renderMutation(ctx, spec, entity, fromFile);
+}