domain-driver 0.1.0 → 0.3.0

package/dist/stack/detect.js

@@ -0,0 +1,125 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetStackCache = resetStackCache;
+exports.detectStack = detectStack;
+exports.describeStack = describeStack;
+const fs = __importStar(require("fs"));
+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'];
+let cached;
+function resetStackCache() {
+    cached = undefined;
+}
+function detectStack(override) {
+    if (cached)
+        return cached;
+    const cwd = process.cwd();
+    const overridden = override !== undefined;
+    const deps = readDependencies(cwd, overridden);
+    const stack = overridden ? parseOverride(override) : inferStack(cwd, deps);
+    const result = Object.freeze({
+        stack,
+        source: overridden ? 'override' : 'detected',
+        httpFramework: stack === 'node' ? detectHttpFramework(deps) : null,
+        featureRoot: resolveFeatureRoot(cwd, stack),
+        hasNestjsZod: deps.has('nestjs-zod'),
+    });
+    cached = result;
+    return result;
+}
+function describeStack(stack) {
+    const base = `Stack: ${stack.stack} (${stack.source})`;
+    if (stack.stack !== 'node')
+        return base;
+    return `${base}, http: ${stack.httpFramework ?? 'none'}`;
+}
+function readDependencies(cwd, optional) {
+    const pkgPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgPath)) {
+        if (optional)
+            return new Set();
+        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 new Set([
+        ...Object.keys(pkg.dependencies ?? {}),
+        ...Object.keys(pkg.devDependencies ?? {}),
+    ]);
+}
+function parsePackageJson(pkgPath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        return (parsed ?? {});
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Could not parse package.json: ${message}`);
+    }
+}
+function parseOverride(value) {
+    if ((0, types_1.isStackName)(value))
+        return value;
+    throw new Error(`Unknown stack "${value}". Valid stacks: ${types_1.STACK_NAMES.join(', ')}.`);
+}
+function inferStack(cwd, deps) {
+    if (deps.has('@nestjs/core'))
+        return 'nest';
+    if (deps.has('next'))
+        return hasApiDir(cwd) ? 'next-fullstack' : 'next-frontend';
+    if (deps.has('react'))
+        return 'react';
+    return 'node';
+}
+function hasApiDir(cwd) {
+    return API_DIRS.some((dir) => (0, fs_1.isDirectory)(path.join(cwd, dir)));
+}
+function detectHttpFramework(deps) {
+    return types_1.HTTP_FRAMEWORKS.find((name) => deps.has(name)) ?? null;
+}
+function resolveFeatureRoot(cwd, stack) {
+    switch (stack) {
+        case 'next-fullstack':
+        case 'next-frontend':
+            return (0, fs_1.isDirectory)(path.join(cwd, 'src', 'app')) ? 'src/app' : 'app';
+        case 'react':
+        case 'node':
+            return (0, fs_1.isDirectory)(path.join(cwd, 'src')) ? 'src/features' : 'features';
+        case 'nest':
+            return 'src';
+    }
+}

package/dist/stack/profiles/nest.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nest = void 0;
+exports.nest = Object.freeze({
+    name: 'nest',
+    folders: ['controllers', 'services', 'repositories', 'schemas', 'dto', 'types'],
+    layers: ['serverService', 'serverRepository', 'controller', 'module', 'dto', 'schema', 'types'],
+    layerDirs: {
+        serverService: 'services',
+        serverRepository: 'repositories',
+        controller: 'controllers',
+        dto: 'dto',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: false,
+    serverComponents: false,
+});

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextFrontend = void 0;
+exports.nextFrontend = Object.freeze({
+    name: 'next-frontend',
+    folders: [
+        'components/client',
+        'components/server',
+        'containers',
+        'hooks',
+        'services',
+        'repositories',
+        'schemas',
+        'types',
+    ],
+    layers: ['page', 'component', 'container', 'hook', 'clientService', 'clientRepository', 'schema', 'types'],
+    layerDirs: {
+        component: 'components',
+        container: 'containers',
+        hook: 'hooks',
+        clientService: 'services',
+        clientRepository: 'repositories',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: true,
+    serverComponents: true,
+});

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextFullstack = void 0;
+exports.nextFullstack = Object.freeze({
+    name: 'next-fullstack',
+    folders: [
+        'components/client',
+        'components/server',
+        'containers',
+        'hooks',
+        'client/services',
+        'client/repositories',
+        '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',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: true,
+    serverComponents: true,
+});

package/dist/stack/profiles/node.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.node = void 0;
+exports.node = Object.freeze({
+    name: 'node',
+    folders: ['controllers', 'services', 'repositories', 'schemas', 'types'],
+    layers: ['serverService', 'serverRepository', 'controller', 'schema', 'types'],
+    layerDirs: {
+        serverService: 'services',
+        serverRepository: 'repositories',
+        controller: 'controllers',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: false,
+    serverComponents: false,
+});

package/dist/stack/profiles/react.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.react = void 0;
+exports.react = Object.freeze({
+    name: 'react',
+    folders: ['components', 'containers', 'hooks', 'services', 'repositories', 'schemas', 'types'],
+    layers: ['component', 'container', 'hook', 'clientService', 'clientRepository', 'schema', 'types'],
+    layerDirs: {
+        component: 'components',
+        container: 'containers',
+        hook: 'hooks',
+        clientService: 'services',
+        clientRepository: 'repositories',
+        schema: 'schemas',
+        types: 'types',
+    },
+    clientDirective: false,
+    serverComponents: false,
+});

package/dist/stack/registry.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProfile = getProfile;
+exports.hasLayer = hasLayer;
+exports.layerDir = layerDir;
+exports.componentDir = componentDir;
+exports.availableCommands = availableCommands;
+exports.assertLayer = assertLayer;
+const next_fullstack_1 = require("./profiles/next-fullstack");
+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 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,
+});
+const LAYER_COMMANDS = Object.freeze({
+    component: 'make:component',
+    container: 'make:container',
+    hook: 'make:hook',
+    clientService: 'make:service',
+    serverService: 'make:service',
+    clientRepository: 'make:repository',
+    serverRepository: 'make:repository',
+    controller: 'make:controller',
+    schema: 'make:schema',
+    dto: 'make:schema',
+    types: 'make:types',
+});
+function getProfile(stack) {
+    return PROFILES[stack];
+}
+function hasLayer(profile, layer) {
+    return profile.layers.includes(layer);
+}
+function layerDir(profile, layer) {
+    const dir = profile.layerDirs[layer];
+    if (dir === undefined) {
+        throw new Error(`Layer "${layer}" has no directory in the ${profile.name} profile.`);
+    }
+    return dir;
+}
+function componentDir(profile, type) {
+    return profile.serverComponents ? `components/${type}` : 'components';
+}
+function availableCommands(profile) {
+    const commands = profile.layers
+        .map((layer) => LAYER_COMMANDS[layer])
+        .filter((command) => command !== undefined);
+    return [...new Set(commands)];
+}
+function assertLayer(profile, layer, command) {
+    if (hasLayer(profile, layer))
+        return;
+    const escapeHatch = profile.name === 'next-frontend' && layer === 'controller'
+        ? ' Create an app/api directory or pass --stack next-fullstack to enable route handlers.'
+        : '';
+    throw new Error(`${command} is not available for the ${profile.name} stack. Available: ${availableCommands(profile).join(', ')}.${escapeHatch}`);
+}

package/dist/stack/types.js

@@ -0,0 +1,24 @@
+"use strict";
+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.HTTP_FRAMEWORKS = ['express', 'fastify', 'hono'];
+exports.LAYERS = [
+    'page',
+    'component',
+    'container',
+    'hook',
+    'clientService',
+    'clientRepository',
+    'serverService',
+    'serverRepository',
+    'controller',
+    'module',
+    'dto',
+    'schema',
+    'types',
+];
+function isStackName(value) {
+    return exports.STACK_NAMES.includes(value);
+}

package/dist/templates/actions.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETURN_KINDS = exports.WRITE_ACTIONS = exports.ACTIONS = void 0;
+exports.actionCase = actionCase;
+exports.standardAction = standardAction;
+exports.standardActions = standardActions;
+exports.customAction = customAction;
+const naming_1 = require("../utils/naming");
+exports.ACTIONS = ['List', 'Show', 'Create', 'Update', 'Delete'];
+exports.WRITE_ACTIONS = ['Create', 'Update'];
+exports.RETURN_KINDS = ['list', 'one', 'void'];
+const ACTION_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+function actionCase(name) {
+    if (!ACTION_NAME_PATTERN.test(name)) {
+        throw new Error(`Action name "${name}" must be camelCase or PascalCase, for example findActiveUsers.`);
+    }
+    const pascal = (0, naming_1.upperFirst)(name);
+    return Object.freeze({ pascal, camel: (0, naming_1.lowerFirst)(pascal), slug: (0, naming_1.toKebabCase)(pascal) });
+}
+function freeze(spec) {
+    return Object.freeze(spec);
+}
+function returnType(kind, entity) {
+    switch (kind) {
+        case 'list':
+            return `Promise<${entity}[]>`;
+        case 'one':
+            return `Promise<${entity}>`;
+        case 'void':
+            return 'Promise<void>';
+    }
+}
+function standardAction(action, entity) {
+    const name = `${action}${entity}`;
+    const handler = `${(0, naming_1.lowerFirst)(action)}${entity}Controller`;
+    switch (action) {
+        case 'List':
+            return freeze({ name, handler, params: '', args: '', returns: `Promise<${entity}[]>`, usesEntityType: true, schema: null, usesId: false, status: 200, method: 'get', path: '/', failure: `Failed to fetch ${entity} list` });
+        case 'Show':
+            return freeze({ name, handler, params: 'id: string', args: 'id', returns: `Promise<${entity}>`, usesEntityType: true, schema: null, usesId: true, status: 200, method: 'get', path: '/:id', failure: `Failed to fetch ${entity}` });
+        case 'Create':
+            return freeze({ name, handler, params: `data: ${name}`, args: 'data', returns: `Promise<${entity}>`, usesEntityType: true, schema: name, usesId: false, status: 201, method: 'post', path: '/', failure: `Failed to create ${entity}` });
+        case 'Update':
+            return freeze({ name, handler, params: `id: string, data: ${name}`, args: 'id, data', returns: `Promise<${entity}>`, usesEntityType: true, schema: name, usesId: true, status: 200, method: 'put', path: '/:id', failure: `Failed to update ${entity}` });
+        case 'Delete':
+            return freeze({ name, handler, params: 'id: string', args: 'id', returns: 'Promise<void>', usesEntityType: false, schema: null, usesId: true, status: 204, method: 'delete', path: '/:id', failure: `Failed to delete ${entity}` });
+    }
+}
+function standardActions(entity) {
+    return exports.ACTIONS.map((action) => standardAction(action, entity));
+}
+function customAction(entity, actionName, options) {
+    const { pascal, camel, slug } = actionCase(actionName);
+    return freeze({
+        name: pascal,
+        handler: `${camel}Controller`,
+        params: options.withInput ? `data: ${pascal}` : '',
+        args: options.withInput ? 'data' : '',
+        returns: returnType(options.returns, entity),
+        usesEntityType: options.returns !== 'void',
+        schema: options.withInput ? pascal : null,
+        usesId: false,
+        status: options.returns === 'void' ? 204 : 200,
+        method: options.withInput ? 'post' : 'get',
+        path: `/${slug}`,
+        failure: `Failed to ${camel} ${entity}`,
+    });
+}

package/dist/templates/backend/server-repository.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderServerRepository = renderServerRepository;
+const injectable_1 = require("../nest/injectable");
+const signatures_1 = require("../signatures");
+function renderServerRepository(ctx, spec, entity, fromFile) {
+    const cls = `${spec.name}Repository`;
+    const injectable = ctx.profile.name === 'nest';
+    const imports = [
+        ...(injectable ? [injectable_1.INJECTABLE_IMPORT] : []),
+        ...(0, signatures_1.domainImports)(ctx, fromFile, spec, entity),
+    ].join('\n');
+    const header = imports ? `${imports}\n\n` : '';
+    const decorator = injectable ? '@Injectable()\n' : '';
+    return `${header}${decorator}export class ${cls} {
+  async handle(${spec.params}): ${spec.returns} {
+    // TODO: implement with your ORM (Prisma, Drizzle, TypeORM, ...)
+    throw new Error('${cls}.handle is not implemented');
+  }
+}
+`;
+}

package/dist/templates/context.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createContext = createContext;
+const path = __importStar(require("path"));
+const registry_1 = require("../stack/registry");
+const imports_1 = require("../utils/imports");
+const paths_1 = require("../utils/paths");
+function createContext(feature, stack, profile) {
+    const dir = (0, paths_1.featureDir)(stack, feature);
+    const importFrom = (fromFile, relative) => (0, imports_1.resolveImport)(fromFile, path.join(dir, relative));
+    return Object.freeze({
+        feature,
+        stack,
+        profile,
+        featureDir: dir,
+        importFrom,
+        importLayer: (fromFile, layer, fileName) => importFrom(fromFile, `${(0, registry_1.layerDir)(profile, layer)}/${fileName}`),
+    });
+}

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});
+  }
+}
+`;
+}