domain-driver 0.1.0 → 0.2.0

package/dist/templates/controllers/express.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderExpressController = renderExpressController;
+exports.renderExpressRoutes = renderExpressRoutes;
+const naming_1 = require("../../utils/naming");
+const actions_1 = require("../actions");
+const shape_1 = require("./shape");
+function renderExpressController(ctx, spec, fromFile) {
+    const imports = [
+        "import { NextFunction, Request, Response } from 'express';",
+        ...(spec.schema !== null ? [(0, shape_1.schemaImport)(ctx, fromFile, spec.schema)] : []),
+        (0, shape_1.serviceImport)(ctx, fromFile, spec),
+    ].join('\n');
+    const reqName = spec.schema !== null || spec.usesId ? 'req' : '_req';
+    const requestType = spec.usesId ? 'Request<{ id: string }>' : 'Request';
+    const validate = spec.schema !== null
+        ? `  const parsed = ${spec.schema}Schema.safeParse(req.body);
+  if (!parsed.success) {
+    res.status(400).json({ errors: parsed.error.flatten() });
+    return;
+  }
+`
+        : '';
+    const args = (0, shape_1.callArgs)(spec, 'req.params.id', 'parsed.data');
+    const respond = spec.status === 204
+        ? `    await service.handle(${args});
+    res.status(204).send();`
+        : `    res.status(${spec.status}).json(await service.handle(${args}));`;
+    return `${imports}
+
+const service = new ${spec.name}Service();
+
+export async function ${spec.handler}(${reqName}: ${requestType}, res: Response, next: NextFunction): Promise<void> {
+${validate}  try {
+${respond}
+  } catch (error) {
+    next(error);
+  }
+}
+`;
+}
+function renderExpressRoutes(ctx, entity, fromFile) {
+    const name = (0, naming_1.lowerFirst)(entity);
+    const handler = (action) => (0, actions_1.standardAction)(action, entity).handler;
+    return `import { Router } from 'express';
+${(0, shape_1.controllerImports)(ctx, fromFile, entity)}
+
+const router = Router();
+
+router.get('/', ${handler('List')});
+router.get('/:id', ${handler('Show')});
+router.post('/', ${handler('Create')});
+router.put('/:id', ${handler('Update')});
+router.delete('/:id', ${handler('Delete')});
+
+export default router;
+
+// app.use('/${ctx.feature}', ${name}Routes);
+`;
+}

package/dist/templates/controllers/fastify.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderFastifyController = renderFastifyController;
+exports.renderFastifyRoutes = renderFastifyRoutes;
+const naming_1 = require("../../utils/naming");
+const actions_1 = require("../actions");
+const shape_1 = require("./shape");
+function renderFastifyController(ctx, spec, fromFile) {
+    const imports = [
+        "import { FastifyReply, FastifyRequest } from 'fastify';",
+        ...(spec.schema !== null ? [(0, shape_1.schemaImport)(ctx, fromFile, spec.schema)] : []),
+        (0, shape_1.serviceImport)(ctx, fromFile, spec),
+    ].join('\n');
+    const requestType = spec.usesId ? 'FastifyRequest<{ Params: { id: string } }>' : 'FastifyRequest';
+    const requestName = spec.schema !== null || spec.usesId ? 'request' : '_request';
+    const validate = spec.schema !== null
+        ? `  const parsed = ${spec.schema}Schema.safeParse(request.body);
+  if (!parsed.success) {
+    reply.status(400).send({ errors: parsed.error.flatten() });
+    return;
+  }
+`
+        : '';
+    const args = (0, shape_1.callArgs)(spec, 'request.params.id', 'parsed.data');
+    const respond = spec.status === 204
+        ? `  await service.handle(${args});
+  reply.status(204).send();`
+        : `  reply.status(${spec.status}).send(await service.handle(${args}));`;
+    return `${imports}
+
+const service = new ${spec.name}Service();
+
+export async function ${spec.handler}(${requestName}: ${requestType}, reply: FastifyReply): Promise<void> {
+${validate}${respond}
+}
+`;
+}
+function renderFastifyRoutes(ctx, entity, fromFile) {
+    const name = (0, naming_1.lowerFirst)(entity);
+    const handler = (action) => (0, actions_1.standardAction)(action, entity).handler;
+    return `import { FastifyInstance } from 'fastify';
+${(0, shape_1.controllerImports)(ctx, fromFile, entity)}
+
+export async function ${name}Routes(app: FastifyInstance): Promise<void> {
+  app.get('/', ${handler('List')});
+  app.get('/:id', ${handler('Show')});
+  app.post('/', ${handler('Create')});
+  app.put('/:id', ${handler('Update')});
+  app.delete('/:id', ${handler('Delete')});
+}
+
+// app.register(${name}Routes, { prefix: '/${ctx.feature}' });
+`;
+}

package/dist/templates/controllers/generic.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderGenericController = renderGenericController;
+const shape_1 = require("./shape");
+function renderGenericController(ctx, spec, entity, fromFile) {
+    const typeImport = spec.usesEntityType
+        ? [`import { ${entity} } from '${ctx.importLayer(fromFile, 'types', `${entity}.types`)}';`]
+        : [];
+    const imports = [
+        ...typeImport,
+        ...(spec.schema !== null ? [(0, shape_1.schemaImport)(ctx, fromFile, spec.schema)] : []),
+        (0, shape_1.serviceImport)(ctx, fromFile, spec),
+    ].join('\n');
+    const params = [spec.usesId ? 'id: string' : null, spec.schema !== null ? 'input: unknown' : null]
+        .filter((param) => param !== null)
+        .join(', ');
+    const args = [spec.usesId ? 'id' : null, spec.schema !== null ? `${spec.schema}Schema.parse(input)` : null]
+        .filter((arg) => arg !== null)
+        .join(', ');
+    return `${imports}
+
+const service = new ${spec.name}Service();
+
+export class ${spec.name}Controller {
+  async handle(${params}): ${spec.returns} {
+    return service.handle(${args});
+  }
+}
+`;
+}

package/dist/templates/controllers/hono.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHonoController = renderHonoController;
+exports.renderHonoRoutes = renderHonoRoutes;
+const naming_1 = require("../../utils/naming");
+const actions_1 = require("../actions");
+const shape_1 = require("./shape");
+function renderHonoController(ctx, spec, fromFile) {
+    const imports = [
+        "import { Context } from 'hono';",
+        ...(spec.schema !== null ? [(0, shape_1.schemaImport)(ctx, fromFile, spec.schema)] : []),
+        (0, shape_1.serviceImport)(ctx, fromFile, spec),
+    ].join('\n');
+    const contextType = spec.usesId ? "Context<{}, '/:id'>" : 'Context';
+    const validate = spec.schema !== null
+        ? `  const parsed = ${spec.schema}Schema.safeParse(await c.req.json());
+  if (!parsed.success) return c.json({ errors: parsed.error.flatten() }, 400);
+`
+        : '';
+    const args = (0, shape_1.callArgs)(spec, "c.req.param('id')", 'parsed.data');
+    const respond = spec.status === 204
+        ? `  await service.handle(${args});
+  return c.body(null, 204);`
+        : `  return c.json(await service.handle(${args}), ${spec.status});`;
+    return `${imports}
+
+const service = new ${spec.name}Service();
+
+export async function ${spec.handler}(c: ${contextType}): Promise<Response> {
+${validate}${respond}
+}
+`;
+}
+function renderHonoRoutes(ctx, entity, fromFile) {
+    const name = (0, naming_1.lowerFirst)(entity);
+    const handler = (action) => (0, actions_1.standardAction)(action, entity).handler;
+    return `import { Hono } from 'hono';
+${(0, shape_1.controllerImports)(ctx, fromFile, entity)}
+
+const ${name} = new Hono();
+
+${name}.get('/', ${handler('List')});
+${name}.get('/:id', ${handler('Show')});
+${name}.post('/', ${handler('Create')});
+${name}.put('/:id', ${handler('Update')});
+${name}.delete('/:id', ${handler('Delete')});
+
+export default ${name};
+
+// app.route('/${ctx.feature}', ${name});
+`;
+}

package/dist/templates/controllers/nest.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderNestController = renderNestController;
+const shape_1 = require("./shape");
+const METHOD_DECORATORS = Object.freeze({
+    get: 'Get',
+    post: 'Post',
+    put: 'Put',
+    delete: 'Delete',
+});
+const NEST_DEFAULT_STATUS = Object.freeze({
+    get: 200,
+    post: 201,
+    put: 200,
+    delete: 200,
+});
+function nestRoute(spec) {
+    const decoratorName = METHOD_DECORATORS[spec.method];
+    const routePath = spec.path === '/' ? '' : spec.path.slice(1);
+    const route = `@${decoratorName}(${routePath ? `'${routePath}'` : ''})`;
+    const needsHttpCode = spec.status !== NEST_DEFAULT_STATUS[spec.method];
+    const decorator = needsHttpCode ? `${route}\n  @HttpCode(${spec.status})` : route;
+    const commonImports = [
+        'Controller',
+        decoratorName,
+        ...(spec.schema !== null ? ['Body'] : []),
+        ...(spec.usesId ? ['Param'] : []),
+        ...(needsHttpCode ? ['HttpCode'] : []),
+    ].sort();
+    return { decorator, commonImports };
+}
+function renderNestController(ctx, spec, entity, fromFile) {
+    const route = nestRoute(spec);
+    const dto = spec.schema !== null ? `${spec.schema}Dto` : null;
+    const imports = [
+        `import { ${route.commonImports.join(', ')} } from '@nestjs/common';`,
+        ...(spec.usesEntityType
+            ? [`import { ${entity} } from '${ctx.importLayer(fromFile, 'types', `${entity}.types`)}';`]
+            : []),
+        ...(dto !== null && spec.schema !== null
+            ? [`import { ${dto} } from '${ctx.importLayer(fromFile, 'dto', `${spec.schema}.dto`)}';`]
+            : []),
+        (0, shape_1.serviceImport)(ctx, fromFile, spec),
+    ].join('\n');
+    const params = [spec.usesId ? "@Param('id') id: string" : null, dto !== null ? `@Body() body: ${dto}` : null]
+        .filter((param) => param !== null)
+        .join(', ');
+    const args = [spec.usesId ? 'id' : null, dto !== null ? 'body' : null]
+        .filter((arg) => arg !== null)
+        .join(', ');
+    return `${imports}
+
+@Controller('${ctx.feature}')
+export class ${spec.name}Controller {
+  constructor(private readonly service: ${spec.name}Service) {}
+
+  ${route.decorator}
+  handle(${params}): ${spec.returns} {
+    return this.service.handle(${args});
+  }
+}
+`;
+}

package/dist/templates/controllers/next-action-route.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderActionRoute = renderActionRoute;
+const shape_1 = require("./shape");
+function renderActionRoute(ctx, spec, fromFile) {
+    const imports = [
+        "import { NextResponse } from 'next/server';",
+        ...(spec.schema !== null ? [(0, shape_1.schemaImport)(ctx, fromFile, spec.schema)] : []),
+        (0, shape_1.serviceImport)(ctx, fromFile, spec),
+    ].join('\n');
+    const method = spec.method.toUpperCase();
+    const requestParam = spec.schema !== null ? 'request: Request' : '';
+    const validate = spec.schema !== null
+        ? `  const parsed = ${spec.schema}Schema.safeParse(await request.json());
+  if (!parsed.success) {
+    return NextResponse.json({ errors: parsed.error.flatten() }, { status: 400 });
+  }
+`
+        : '';
+    const args = spec.schema !== null ? 'parsed.data' : '';
+    if (spec.status === 204) {
+        return `${imports}
+
+const service = new ${spec.name}Service();
+
+export async function ${method}(${requestParam}): Promise<Response> {
+${validate}  await service.handle(${args});
+  return new Response(null, { status: 204 });
+}
+`;
+    }
+    return `${imports}
+
+const service = new ${spec.name}Service();
+
+export async function ${method}(${requestParam}): Promise<NextResponse> {
+${validate}  return NextResponse.json(await service.handle(${args}));
+}
+`;
+}

package/dist/templates/controllers/next-route.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCollectionRoute = renderCollectionRoute;
+exports.renderItemRoute = renderItemRoute;
+const actions_1 = require("../actions");
+const shape_1 = require("./shape");
+function renderCollectionRoute(ctx, entity, fromFile) {
+    return `import { NextResponse } from 'next/server';
+${(0, shape_1.schemaImport)(ctx, fromFile, `Create${entity}`)}
+${(0, shape_1.serviceImport)(ctx, fromFile, (0, actions_1.standardAction)('List', entity))}
+${(0, shape_1.serviceImport)(ctx, fromFile, (0, actions_1.standardAction)('Create', entity))}
+
+const listService = new List${entity}Service();
+const createService = new Create${entity}Service();
+
+export async function GET(): Promise<NextResponse> {
+  return NextResponse.json(await listService.handle());
+}
+
+export async function POST(request: Request): Promise<NextResponse> {
+  const parsed = Create${entity}Schema.safeParse(await request.json());
+  if (!parsed.success) {
+    return NextResponse.json({ errors: parsed.error.flatten() }, { status: 400 });
+  }
+  return NextResponse.json(await createService.handle(parsed.data), { status: 201 });
+}
+`;
+}
+function renderItemRoute(ctx, entity, fromFile) {
+    return `import { NextResponse } from 'next/server';
+${(0, shape_1.schemaImport)(ctx, fromFile, `Update${entity}`)}
+${(0, shape_1.serviceImport)(ctx, fromFile, (0, actions_1.standardAction)('Show', entity))}
+${(0, shape_1.serviceImport)(ctx, fromFile, (0, actions_1.standardAction)('Update', entity))}
+${(0, shape_1.serviceImport)(ctx, fromFile, (0, actions_1.standardAction)('Delete', entity))}
+
+const showService = new Show${entity}Service();
+const updateService = new Update${entity}Service();
+const deleteService = new Delete${entity}Service();
+
+type RouteContext = { params: Promise<{ id: string }> };
+
+export async function GET(_request: Request, { params }: RouteContext): Promise<NextResponse> {
+  const { id } = await params;
+  return NextResponse.json(await showService.handle(id));
+}
+
+export async function PUT(request: Request, { params }: RouteContext): Promise<NextResponse> {
+  const { id } = await params;
+  const parsed = Update${entity}Schema.safeParse(await request.json());
+  if (!parsed.success) {
+    return NextResponse.json({ errors: parsed.error.flatten() }, { status: 400 });
+  }
+  return NextResponse.json(await updateService.handle(id, parsed.data));
+}
+
+export async function DELETE(_request: Request, { params }: RouteContext): Promise<Response> {
+  const { id } = await params;
+  await deleteService.handle(id);
+  return new Response(null, { status: 204 });
+}
+`;
+}

package/dist/templates/controllers/node.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderNodeController = renderNodeController;
+exports.renderNodeRoutes = renderNodeRoutes;
+exports.renderNodeRouteLine = renderNodeRouteLine;
+const naming_1 = require("../../utils/naming");
+const express_1 = require("./express");
+const fastify_1 = require("./fastify");
+const hono_1 = require("./hono");
+const generic_1 = require("./generic");
+function renderNodeController(ctx, spec, entity, fromFile) {
+    switch (ctx.stack.httpFramework) {
+        case 'express':
+            return (0, express_1.renderExpressController)(ctx, spec, fromFile);
+        case 'fastify':
+            return (0, fastify_1.renderFastifyController)(ctx, spec, fromFile);
+        case 'hono':
+            return (0, hono_1.renderHonoController)(ctx, spec, fromFile);
+        case null:
+            return (0, generic_1.renderGenericController)(ctx, spec, entity, fromFile);
+    }
+}
+function renderNodeRoutes(ctx, entity, fromFile) {
+    switch (ctx.stack.httpFramework) {
+        case 'express':
+            return (0, express_1.renderExpressRoutes)(ctx, entity, fromFile);
+        case 'fastify':
+            return (0, fastify_1.renderFastifyRoutes)(ctx, entity, fromFile);
+        case 'hono':
+            return (0, hono_1.renderHonoRoutes)(ctx, entity, fromFile);
+        case null:
+            return null;
+    }
+}
+function renderNodeRouteLine(ctx, spec, entity) {
+    switch (ctx.stack.httpFramework) {
+        case 'express':
+            return `router.${spec.method}('${spec.path}', ${spec.handler});`;
+        case 'fastify':
+            return `app.${spec.method}('${spec.path}', ${spec.handler});`;
+        case 'hono':
+            return `${(0, naming_1.lowerFirst)(entity)}.${spec.method}('${spec.path}', ${spec.handler});`;
+        case null:
+            return null;
+    }
+}

package/dist/templates/controllers/shape.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaImport = schemaImport;
+exports.serviceImport = serviceImport;
+exports.controllerImports = controllerImports;
+exports.callArgs = callArgs;
+const actions_1 = require("../actions");
+function schemaImport(ctx, fromFile, schemaName) {
+    const schemaPath = ctx.importLayer(fromFile, 'schema', `${schemaName}.schema`);
+    return `import { ${schemaName}Schema } from '${schemaPath}';`;
+}
+function serviceImport(ctx, fromFile, spec) {
+    const servicePath = ctx.importLayer(fromFile, 'serverService', `${spec.name}.service`);
+    return `import { ${spec.name}Service } from '${servicePath}';`;
+}
+function controllerImports(ctx, fromFile, entity) {
+    return (0, actions_1.standardActions)(entity)
+        .map((spec) => {
+        const controllerPath = ctx.importLayer(fromFile, 'controller', `${spec.name}.controller`);
+        return `import { ${spec.handler} } from '${controllerPath}';`;
+    })
+        .join('\n');
+}
+function callArgs(spec, idExpression, bodyExpression) {
+    return [spec.usesId ? idExpression : null, spec.schema !== null ? bodyExpression : null]
+        .filter((arg) => arg !== null)
+        .join(', ');
+}

package/dist/templates/frontend/client-repository.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderClientRepository = renderClientRepository;
+const signatures_1 = require("../signatures");
+const JSON_HEADERS = "headers: { 'Content-Type': 'application/json' },";
+function fetchUrl(spec, base) {
+    if (!spec.path.includes(':id'))
+        return `'${base}${spec.path === '/' ? '' : spec.path}'`;
+    return `\`${base}${spec.path.replace(':id', '${id}')}\``;
+}
+function fetchCall(spec, base) {
+    const url = fetchUrl(spec, base);
+    if (spec.method === 'get')
+        return url;
+    const method = spec.method.toUpperCase();
+    if (spec.schema === null) {
+        return `${url}, {
+      method: '${method}',
+    }`;
+    }
+    return `${url}, {
+      method: '${method}',
+      ${JSON_HEADERS}
+      body: JSON.stringify(data),
+    }`;
+}
+function renderClientRepository(ctx, spec, entity, fromFile) {
+    const imports = (0, signatures_1.domainImports)(ctx, fromFile, spec, entity).join('\n');
+    const header = imports ? `${imports}\n\n` : '';
+    const returnLine = spec.returns === 'Promise<void>' ? '' : '    return response.json();\n';
+    return `${header}export class ${spec.name}Repository {
+  async handle(${spec.params}): ${spec.returns} {
+    const response = await fetch(${fetchCall(spec, `/api/${ctx.feature}`)});
+    if (!response.ok) throw new Error('${spec.failure}');
+${returnLine}  }
+}
+`;
+}

package/dist/templates/frontend/component.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderComponent = renderComponent;
+function renderComponent(name, directive) {
+    const header = directive ? "'use client';\n\n" : '';
+    return `${header}interface ${name}Props {
+  id: string;
+}
+
+export default function ${name}({ id }: ${name}Props) {
+  return (
+    <div>
+      <h1>${name} {id}</h1>
+    </div>
+  );
+}
+`;
+}

package/dist/templates/frontend/container.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 componentPath = ctx.importFrom(fromFile, `${(0, registry_1.componentDir)(ctx.profile, 'client')}/${entity}`);
+    return `${header}import { ${hookName} } from '${hookPath}';
+import ${entity} from '${componentPath}';
+
+export default function ${containerName}() {
+  const { items, loading, error } = ${hookName}();
+
+  if (loading) return <div>Loading...</div>;
+  if (error) return <div>Error: {error}</div>;
+
+  return (
+    <div>
+      {items.map((item) => (
+        <${entity} key={item.id} {...item} />
+      ))}
+    </div>
+  );
+}
+`;
+}

package/{src/commands/hook.ts → dist/templates/frontend/hook.js}

@@ -1,32 +1,32 @@
-import * as path from 'path';
-import { ensureFeatureExists, writeFileSafe, fileExists, resolveImport } from '../utils';
-
-function renderHook(hookName: string, name: string, feature: string): string {
-    const typePath = resolveImport(feature, `types/${name}.types`);
-    const svcPath = (op: string) => resolveImport(feature, `services/${op}${name}.service`);
-    const schemaPath = (op: string) => resolveImport(feature, `schemas/${op}${name}.schema`);
-
-    return `'use client';
-
-import { useState, useEffect, useCallback } from 'react';
-import { ${name} } from '${typePath}';
-import { List${name}Service } from '${svcPath('List')}';
-import { Show${name}Service } from '${svcPath('Show')}';
-import { Create${name}Service } from '${svcPath('Create')}';
-import { Update${name}Service } from '${svcPath('Update')}';
-import { Delete${name}Service } from '${svcPath('Delete')}';
-import { Create${name} } from '${schemaPath('Create')}';
-import { Update${name} } from '${schemaPath('Update')}';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHook = renderHook;
+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');
+}
+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}';
 
-const listService = new List${name}Service();
-const showService = new Show${name}Service();
-const createService = new Create${name}Service();
-const updateService = new Update${name}Service();
-const deleteService = new Delete${name}Service();
+${serviceInstances(entity)}
 
 export function ${hookName}() {
-  const [items, setItems] = useState<${name}[]>([]);
-  const [selected, setSelected] = useState<${name} | null>(null);
+  const [items, setItems] = useState<${entity}[]>([]);
+  const [selected, setSelected] = useState<${entity} | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
 
@@ -56,7 +56,7 @@ export function ${hookName}() {
     }
   }, []);
 
-  const create = useCallback(async (data: Create${name}) => {
+  const create = useCallback(async (data: Create${entity}) => {
     setLoading(true);
     setError(null);
     try {
@@ -71,7 +71,7 @@ export function ${hookName}() {
     }
   }, []);
 
-  const update = useCallback(async (id: string, data: Update${name}) => {
+  const update = useCallback(async (id: string, data: Update${entity}) => {
     setLoading(true);
     setError(null);
     try {
@@ -107,16 +107,3 @@ export function ${hookName}() {
 }
 `;
 }
-
-export function makeHook(feature: string, name: string, pascalName?: string): void {
-    const base = ensureFeatureExists(feature, 'hooks');
-    const filePath = path.join(base, `${name}.ts`);
-
-    if (fileExists(filePath)) {
-        throw new Error(`Hook "${name}" already exists at ${filePath}`);
-    }
-
-    const entityName = pascalName ?? name.replace(/^use/, '');
-    writeFileSafe(filePath, renderHook(name, entityName, feature));
-    console.log(`✅ Hook "${name}" created at ${filePath}`);
-}

package/dist/templates/frontend/page.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPage = renderPage;
+function renderPage(ctx, entity, fromFile, withContainer) {
+    if (!withContainer) {
+        return `export default function ${entity}Page() {
+  return (
+    <div>
+      <h1>${entity}</h1>
+    </div>
+  );
+}
+`;
+    }
+    const containerPath = ctx.importLayer(fromFile, 'container', `${entity}Container`);
+    return `import ${entity}Container from '${containerPath}';
+
+export default function ${entity}Page() {
+  return (
+    <div>
+      <${entity}Container />
+    </div>
+  );
+}
+`;
+}

package/dist/templates/nest/dto.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderDto = renderDto;
+function renderDto(ctx, name, fromFile) {
+    const schemaName = `${name}Schema`;
+    const schemaPath = ctx.importLayer(fromFile, 'schema', `${name}.schema`);
+    return `import { createZodDto } from 'nestjs-zod';
+import { ${schemaName} } from '${schemaPath}';
+
+export class ${name}Dto extends createZodDto(${schemaName}) {}
+`;
+}