domain-driver 0.0.5 → 0.1.0

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
 const feature_1 = require("./commands/feature");
 const component_1 = require("./commands/component");
 const hook_1 = require("./commands/hook");
@@ -8,60 +9,117 @@ const service_1 = require("./commands/service");
 const schema_1 = require("./commands/schema");
 const repository_1 = require("./commands/repository");
 const container_1 = require("./commands/container");
-const [, , command, feature, name] = process.argv;
-if (!command || !feature) {
-    console.error('Usage: domain-driver <command> [options]');
-    process.exit(1);
-}
-switch (command) {
-    case 'make:feature':
-        const all = process.argv.includes('-a') || process.argv.includes('-A');
-        (0, feature_1.makeFeature)(feature, all).then(() => { });
-        break;
-    case 'make:component':
-        if (!name) {
-            console.error('Usage: domain-driver make:component <feature> <name> [client|server]');
-            process.exit(1);
-        }
-        const type = process.argv[5] || 'client';
-        (0, component_1.makeComponent)(feature, name, type);
-        break;
-    case 'make:hook':
-        if (!name) {
-            console.error('Usage: domain-driver make:hook <feature> <name>');
-            process.exit(1);
-        }
+const types_1 = require("./commands/types");
+const program = new commander_1.Command();
+program
+    .name('domain-driver')
+    .description('CLI scaffolding tool for domain-driven development in Next.js')
+    .version('0.1.0');
+program
+    .command('make:feature <name>')
+    .description('Scaffold a full feature folder structure')
+    .option('-a, --all', 'Scaffold all files inside each folder')
+    .action(async (name, options) => {
+    try {
+        await (0, feature_1.makeFeature)(name, options.all ?? false);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:component <feature> <name>')
+    .description('Scaffold a component inside an existing feature')
+    .argument('[type]', 'Component type: client or server', 'client')
+    .action((feature, name, type) => {
+    try {
+        const componentType = type === 'server' ? 'server' : 'client';
+        (0, component_1.makeComponent)(feature, name, componentType);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:container <feature> <name>')
+    .description('Scaffold a smart container component inside an existing feature')
+    .action((feature, name) => {
+    try {
+        (0, container_1.makeContainer)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:hook <feature> <name>')
+    .description('Scaffold a custom hook inside an existing feature')
+    .action((feature, name) => {
+    try {
         (0, hook_1.makeHook)(feature, name);
-        break;
-    case 'make:service':
-        if (!name) {
-            console.error('Usage: domain-driver make:service <feature> <name>');
-            process.exit(1);
-        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:service <feature> <name>')
+    .description('Scaffold single-responsibility service files inside an existing feature')
+    .action((feature, name) => {
+    try {
         (0, service_1.makeService)(feature, name);
-        break;
-    case 'make:schema':
-        if (!name) {
-            console.error('Usage: domain-driver make:schema <feature> <name>');
-            process.exit(1);
-        }
-        (0, schema_1.makeSchema)(feature, name);
-        break;
-    case 'make:repository':
-        if (!name) {
-            console.error('Usage: domain-driver make:repository <feature> <name>');
-            process.exit(1);
-        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:repository <feature> <name>')
+    .description('Scaffold single-responsibility repository files inside an existing feature')
+    .action((feature, name) => {
+    try {
         (0, repository_1.makeRepository)(feature, name);
-        break;
-    case 'make:container':
-        if (!name) {
-            console.error('Usage: domain-driver make:container <feature> <name>');
-            process.exit(1);
-        }
-        (0, container_1.makeContainer)(feature, name);
-        break;
-    default:
-        console.error(`Unknown command: ${command}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:schema <feature> <name>')
+    .description('Scaffold Zod schemas for create and update operations')
+    .action((feature, name) => {
+    try {
+        (0, schema_1.makeSchema)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
+        process.exit(1);
+    }
+});
+program
+    .command('make:types <feature> <name>')
+    .description('Scaffold a types file inside an existing feature')
+    .action((feature, name) => {
+    try {
+        (0, types_1.makeTypes)(feature, name);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`❌ ${message}`);
         process.exit(1);
-}
+    }
+});
+program.parse();

package/dist/utils.js

@@ -0,0 +1,132 @@
+"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.toPascalCase = toPascalCase;
+exports.featureBasePath = featureBasePath;
+exports.ensureFeatureExists = ensureFeatureExists;
+exports.writeFileSafe = writeFileSafe;
+exports.mkdirSafe = mkdirSafe;
+exports.fileExists = fileExists;
+exports.detectAlias = detectAlias;
+exports.resetAliasCache = resetAliasCache;
+exports.resolveImport = resolveImport;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function toPascalCase(name) {
+    return name
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+function featureBasePath(feature) {
+    return path.join(process.cwd(), 'app', feature);
+}
+function ensureFeatureExists(feature, subdir) {
+    const base = path.join(featureBasePath(feature), subdir);
+    if (!fs.existsSync(base)) {
+        throw new Error(`Feature "${feature}" does not exist. Run: domain-driver make:feature ${feature}`);
+    }
+    return base;
+}
+function writeFileSafe(filePath, content) {
+    try {
+        fs.writeFileSync(filePath, content);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to write ${filePath}: ${message}`);
+    }
+}
+function mkdirSafe(dirPath) {
+    try {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to create directory ${dirPath}: ${message}`);
+    }
+}
+function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+let cachedAlias;
+function detectAlias() {
+    if (cachedAlias)
+        return cachedAlias;
+    const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+        cachedAlias = { alias: null, appDir: 'app' };
+        return cachedAlias;
+    }
+    try {
+        const raw = fs.readFileSync(tsconfigPath, 'utf-8');
+        const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+        const tsconfig = JSON.parse(stripped);
+        const paths = tsconfig?.compilerOptions?.paths;
+        if (paths) {
+            for (const [key, values] of Object.entries(paths)) {
+                const targets = values;
+                const hasAppMapping = targets.some((v) => v === './app/*' || v === 'app/*' || v === './src/app/*' || v === 'src/app/*');
+                if (hasAppMapping && key.endsWith('/*')) {
+                    const prefix = key.slice(0, -1);
+                    const appDir = targets[0].replace('/*', '').replace('./', '');
+                    cachedAlias = { alias: prefix, appDir };
+                    return cachedAlias;
+                }
+                const hasSrcMapping = targets.some((v) => v === './src/*' || v === 'src/*' || v === './*');
+                if (hasSrcMapping && key.endsWith('/*')) {
+                    const prefix = key.slice(0, -1);
+                    cachedAlias = { alias: prefix, appDir: 'app' };
+                    return cachedAlias;
+                }
+            }
+        }
+    }
+    catch {
+        // tsconfig parse failed, fall back to relative imports
+    }
+    cachedAlias = { alias: null, appDir: 'app' };
+    return cachedAlias;
+}
+function resetAliasCache() {
+    cachedAlias = undefined;
+}
+function resolveImport(fromFeature, relativePath, fromRoot = false) {
+    const { alias } = detectAlias();
+    if (alias) {
+        return `${alias}app/${fromFeature}/${relativePath}`;
+    }
+    return fromRoot ? `./${relativePath}` : `../${relativePath}`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "domain-driver",
-  "version": "0.0.5",
-  "description": "",
+  "version": "0.1.0",
+  "description": "CLI scaffolding tool for domain-driven development in Next.js",
   "main": "index.js",
   "bin": {
     "domain-driver": "./dist/index.js"
@@ -11,17 +11,18 @@
     "url": "https://github.com/IsaacHatilima/domain-driver"
   },
   "scripts": {
-    "build": "npx tsc",
-    "dev": "ts-node src/index.ts",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc",
+    "test": "vitest run"
   },
   "keywords": [],
-  "author": "",
-  "license": "ISC",
+  "author": "Isaac Hatilima",
+  "license": "MIT",
   "devDependencies": {
-    "@types/node": "^25.4.0"
+    "@types/node": "^25.4.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.2"
   },
   "dependencies": {
-    "typescript": "^5.9.3"
+    "commander": "^14.0.3"
   }
 }

package/src/__tests__/utils.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { toPascalCase, detectAlias, resolveImport, resetAliasCache } from '../utils';
+
+describe('toPascalCase', () => {
+    it('converts kebab-case to PascalCase', () => {
+        expect(toPascalCase('coffee-type')).toBe('CoffeeType');
+    });
+
+    it('handles single word', () => {
+        expect(toPascalCase('user')).toBe('User');
+    });
+
+    it('handles multiple hyphens', () => {
+        expect(toPascalCase('my-long-feature-name')).toBe('MyLongFeatureName');
+    });
+});
+
+describe('detectAlias', () => {
+    let testDir: string;
+    let originalCwd: string;
+
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dd-alias-'));
+        process.chdir(testDir);
+        resetAliasCache();
+    });
+
+    afterEach(() => {
+        process.chdir(originalCwd);
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+
+    it('returns null alias when no tsconfig exists', () => {
+        const result = detectAlias();
+        expect(result.alias).toBeNull();
+    });
+
+    it('detects @/ alias mapping to ./app/*', () => {
+        fs.writeFileSync(
+            path.join(testDir, 'tsconfig.json'),
+            JSON.stringify({
+                compilerOptions: {
+                    paths: { '@/*': ['./app/*'] },
+                },
+            })
+        );
+        const result = detectAlias();
+        expect(result.alias).toBe('@/');
+    });
+
+    it('detects @/ alias mapping to ./src/*', () => {
+        fs.writeFileSync(
+            path.join(testDir, 'tsconfig.json'),
+            JSON.stringify({
+                compilerOptions: {
+                    paths: { '@/*': ['./src/*'] },
+                },
+            })
+        );
+        const result = detectAlias();
+        expect(result.alias).toBe('@/');
+    });
+
+    it('detects custom alias like ~/*', () => {
+        fs.writeFileSync(
+            path.join(testDir, 'tsconfig.json'),
+            JSON.stringify({
+                compilerOptions: {
+                    paths: { '~/*': ['./app/*'] },
+                },
+            })
+        );
+        const result = detectAlias();
+        expect(result.alias).toBe('~/');
+    });
+
+    it('returns null when paths has no matching pattern', () => {
+        fs.writeFileSync(
+            path.join(testDir, 'tsconfig.json'),
+            JSON.stringify({
+                compilerOptions: {
+                    paths: { '@components/*': ['./components/*'] },
+                },
+            })
+        );
+        const result = detectAlias();
+        expect(result.alias).toBeNull();
+    });
+});
+
+describe('resolveImport', () => {
+    let testDir: string;
+    let originalCwd: string;
+
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dd-resolve-'));
+        process.chdir(testDir);
+        resetAliasCache();
+    });
+
+    afterEach(() => {
+        process.chdir(originalCwd);
+        fs.rmSync(testDir, { recursive: true, force: true });
+    });
+
+    it('uses relative path when no alias', () => {
+        const result = resolveImport('coffee-type', 'hooks/useCoffeeType');
+        expect(result).toBe('../hooks/useCoffeeType');
+    });
+
+    it('uses alias path when @/ alias exists', () => {
+        fs.writeFileSync(
+            path.join(testDir, 'tsconfig.json'),
+            JSON.stringify({
+                compilerOptions: {
+                    paths: { '@/*': ['./app/*'] },
+                },
+            })
+        );
+        const result = resolveImport('coffee-type', 'hooks/useCoffeeType');
+        expect(result).toBe('@/app/coffee-type/hooks/useCoffeeType');
+    });
+});

package/src/commands/__tests__/feature.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { makeFeature } from '../feature';
+import { resetAliasCache } from '../../utils';
+
+let testDir: string;
+let originalCwd: string;
+
+function cleanup(): void {
+    process.chdir(originalCwd);
+    resetAliasCache();
+    if (fs.existsSync(testDir)) {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    }
+}
+
+describe('make:feature', () => {
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dd-feature-'));
+        process.chdir(testDir);
+        resetAliasCache();
+    });
+    afterEach(cleanup);
+
+    it('creates feature directories with .gitkeep files', async () => {
+        await makeFeature('test-feature', false);
+
+        const base = path.join(testDir, 'app', 'test-feature');
+        expect(fs.existsSync(base)).toBe(true);
+        expect(fs.existsSync(path.join(base, 'components/client/.gitkeep'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'components/server/.gitkeep'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'containers/.gitkeep'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'hooks/.gitkeep'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'services/.gitkeep'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'repositories/.gitkeep'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'schemas/.gitkeep'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'types/.gitkeep'))).toBe(true);
+    });
+
+    it('creates page.tsx with PascalCase component name', async () => {
+        await makeFeature('test-feature', false);
+
+        const page = fs.readFileSync(path.join(testDir, 'app/test-feature/page.tsx'), 'utf-8');
+        expect(page).toContain('TestFeaturePage');
+        expect(page).toContain('export default function');
+    });
+
+    it('throws if feature already exists', async () => {
+        await makeFeature('test-feature', false);
+        await expect(makeFeature('test-feature', false)).rejects.toThrow('already exists');
+    });
+
+    it('scaffolds all files with -a flag', async () => {
+        await makeFeature('coffee-type', true);
+
+        const base = path.join(testDir, 'app', 'coffee-type');
+
+        // No .gitkeep files when -a is used
+        expect(fs.existsSync(path.join(base, 'components/client/.gitkeep'))).toBe(false);
+
+        // All files created with correct names
+        expect(fs.existsSync(path.join(base, 'page.tsx'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'components/client/CoffeeType.tsx'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'containers/CoffeeTypeContainer.tsx'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'hooks/useCoffeeType.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'schemas/CreateCoffeeType.schema.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'schemas/UpdateCoffeeType.schema.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'services/ListCoffeeType.service.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'services/CreateCoffeeType.service.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'repositories/ListCoffeeType.repository.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'repositories/CreateCoffeeType.repository.ts'))).toBe(true);
+        expect(fs.existsSync(path.join(base, 'types/CoffeeType.types.ts'))).toBe(true);
+    });
+
+    it('page imports container when -a flag is used', async () => {
+        await makeFeature('coffee-type', true);
+
+        const page = fs.readFileSync(path.join(testDir, 'app/coffee-type/page.tsx'), 'utf-8');
+        expect(page).toContain("import CoffeeTypeContainer from './containers/CoffeeTypeContainer'");
+        expect(page).toContain('<CoffeeTypeContainer />');
+    });
+});

package/src/commands/__tests__/imports.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { makeFeature } from '../feature';
+import { resetAliasCache } from '../../utils';
+
+let testDir: string;
+let originalCwd: string;
+
+function readFile(relativePath: string): string {
+    return fs.readFileSync(path.join(testDir, 'app', relativePath), 'utf-8');
+}
+
+function cleanup(): void {
+    process.chdir(originalCwd);
+    resetAliasCache();
+    if (fs.existsSync(testDir)) {
+        fs.rmSync(testDir, { recursive: true, force: true });
+    }
+}
+
+describe('inter-layer imports (no alias)', () => {
+    beforeEach(async () => {
+        originalCwd = process.cwd();
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dd-imports-'));
+        process.chdir(testDir);
+        resetAliasCache();
+        await makeFeature('coffee-type', true);
+    });
+    afterEach(cleanup);
+
+    it('types file is created with interface', () => {
+        const content = readFile('coffee-type/types/CoffeeType.types.ts');
+        expect(content).toContain('export interface CoffeeType');
+        expect(content).toContain('id: string');
+    });
+
+    it('container imports hook and component with relative paths', () => {
+        const content = readFile('coffee-type/containers/CoffeeTypeContainer.tsx');
+        expect(content).toContain("from '../hooks/useCoffeeType'");
+        expect(content).toContain("from '../components/client/CoffeeType'");
+    });
+
+    it('hook imports type, services, and schemas with relative paths', () => {
+        const content = readFile('coffee-type/hooks/useCoffeeType.ts');
+        expect(content).toContain("import { CoffeeType } from '../types/CoffeeType.types'");
+        expect(content).toContain("from '../services/ListCoffeeType.service'");
+        expect(content).toContain("from '../schemas/CreateCoffeeType.schema'");
+    });
+
+    it('services import type and repositories with relative paths', () => {
+        const content = readFile('coffee-type/services/CreateCoffeeType.service.ts');
+        expect(content).toContain("import { CoffeeType } from '../types/CoffeeType.types'");
+        expect(content).toContain("from '../repositories/CreateCoffeeType.repository'");
+    });
+
+    it('repositories import type and schema types', () => {
+        const create = readFile('coffee-type/repositories/CreateCoffeeType.repository.ts');
+        expect(create).toContain("import { CoffeeType } from '../types/CoffeeType.types'");
+        expect(create).toContain("from '../schemas/CreateCoffeeType.schema'");
+
+        const list = readFile('coffee-type/repositories/ListCoffeeType.repository.ts');
+        expect(list).toContain("import { CoffeeType } from '../types/CoffeeType.types'");
+    });
+
+    it('delete repository has no schema import but has type import', () => {
+        const del = readFile('coffee-type/repositories/DeleteCoffeeType.repository.ts');
+        expect(del).not.toContain('import');
+    });
+});
+
+describe('inter-layer imports (with @/ alias)', () => {
+    beforeEach(async () => {
+        originalCwd = process.cwd();
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dd-alias-imports-'));
+        process.chdir(testDir);
+        resetAliasCache();
+
+        fs.writeFileSync(
+            path.join(testDir, 'tsconfig.json'),
+            JSON.stringify({
+                compilerOptions: {
+                    paths: { '@/*': ['./app/*'] },
+                },
+            })
+        );
+
+        await makeFeature('coffee-type', true);
+    });
+    afterEach(cleanup);
+
+    it('container imports use @/ alias', () => {
+        const content = readFile('coffee-type/containers/CoffeeTypeContainer.tsx');
+        expect(content).toContain("from '@/app/coffee-type/hooks/useCoffeeType'");
+        expect(content).toContain("from '@/app/coffee-type/components/client/CoffeeType'");
+    });
+
+    it('hook imports use @/ alias', () => {
+        const content = readFile('coffee-type/hooks/useCoffeeType.ts');
+        expect(content).toContain("from '@/app/coffee-type/types/CoffeeType.types'");
+        expect(content).toContain("from '@/app/coffee-type/services/ListCoffeeType.service'");
+    });
+
+    it('services import repositories with @/ alias', () => {
+        const content = readFile('coffee-type/services/CreateCoffeeType.service.ts');
+        expect(content).toContain("from '@/app/coffee-type/types/CoffeeType.types'");
+        expect(content).toContain("from '@/app/coffee-type/repositories/CreateCoffeeType.repository'");
+    });
+
+    it('page imports container with @/ alias', () => {
+        const content = readFile('coffee-type/page.tsx');
+        expect(content).toContain("from '@/app/coffee-type/containers/CoffeeTypeContainer'");
+    });
+});