domain-driver 0.0.5 → 0.1.0

package/src/commands/service.ts

@@ -1,68 +1,93 @@
-import * as fs from 'fs';
 import * as path from 'path';
+import { ensureFeatureExists, writeFileSafe, fileExists, resolveImport } from '../utils';
 
 type ServiceAction = 'List' | 'Create' | 'Update' | 'Delete' | 'Show';
 
 const SERVICE_ACTIONS: ServiceAction[] = ['List', 'Create', 'Update', 'Delete', 'Show'];
 
-function renderService(action: ServiceAction, name: string): string {
+function renderService(action: ServiceAction, name: string, feature: string): string {
+    const typePath = resolveImport(feature, `types/${name}.types`);
+    const repoPath = (op: string) => resolveImport(feature, `repositories/${op}${name}.repository`);
+    const schemaPath = (op: string) => resolveImport(feature, `schemas/${op}${name}.schema`);
+
     switch (action) {
         case 'List':
-            return `export class List${name}Service {
-  async handle() {
-    // fetch all ${name}
+            return `import { ${name} } from '${typePath}';
+import { List${name}Repository } from '${repoPath('List')}';
+
+const repository = new List${name}Repository();
+
+export class List${name}Service {
+  async handle(): Promise<${name}[]> {
+    return repository.handle();
   }
 }
 `;
         case 'Show':
-            return `export class Show${name}Service {
-  async handle(id: string) {
-    // fetch single ${name}
+            return `import { ${name} } from '${typePath}';
+import { Show${name}Repository } from '${repoPath('Show')}';
+
+const repository = new Show${name}Repository();
+
+export class Show${name}Service {
+  async handle(id: string): Promise<${name}> {
+    return repository.handle(id);
   }
 }
 `;
         case 'Create':
-            return `export class Create${name}Service {
-  async handle(data: unknown) {
-    // create ${name}
+            return `import { ${name} } from '${typePath}';
+import { Create${name} } from '${schemaPath('Create')}';
+import { Create${name}Repository } from '${repoPath('Create')}';
+
+const repository = new Create${name}Repository();
+
+export class Create${name}Service {
+  async handle(data: Create${name}): Promise<${name}> {
+    return repository.handle(data);
   }
 }
 `;
         case 'Update':
-            return `export class Update${name}Service {
-  async handle(id: string, data: unknown) {
-    // update ${name}
+            return `import { ${name} } from '${typePath}';
+import { Update${name} } from '${schemaPath('Update')}';
+import { Update${name}Repository } from '${repoPath('Update')}';
+
+const repository = new Update${name}Repository();
+
+export class Update${name}Service {
+  async handle(id: string, data: Update${name}): Promise<${name}> {
+    return repository.handle(id, data);
   }
 }
 `;
         case 'Delete':
-            return `export class Delete${name}Service {
-  async handle(id: string) {
-    // delete ${name}
+            return `import { Delete${name}Repository } from '${repoPath('Delete')}';
+
+const repository = new Delete${name}Repository();
+
+export class Delete${name}Service {
+  async handle(id: string): Promise<void> {
+    return repository.handle(id);
   }
 }
 `;
     }
 }
 
-export function makeService(feature: string, name: string) {
-    const base = path.join(process.cwd(), 'app', feature, 'services');
-
-    if (!fs.existsSync(base)) {
-        console.error(`❌ Feature "${feature}" does not exist. Run make:feature ${feature} first.`);
-        process.exit(1);
-    }
+export function makeService(feature: string, name: string): void {
+    const base = ensureFeatureExists(feature, 'services');
 
     for (const action of SERVICE_ACTIONS) {
         const filePath = path.join(base, `${action}${name}.service.ts`);
 
-        if (fs.existsSync(filePath)) {
+        if (fileExists(filePath)) {
             console.warn(`⚠️  Skipping "${action}${name}.service.ts" — already exists`);
             continue;
         }
 
-        fs.writeFileSync(filePath, renderService(action, name));
+        writeFileSafe(filePath, renderService(action, name, feature));
     }
 
     console.log(`✅ Services for "${name}" created at ${base}`);
-}
+}

package/src/commands/types.ts

@@ -0,0 +1,25 @@
+import * as path from 'path';
+import { ensureFeatureExists, writeFileSafe, fileExists } from '../utils';
+
+function renderTypes(name: string): string {
+    return `export interface ${name} {
+  id: string;
+  // add ${name} fields here
+  createdAt: string;
+  updatedAt: string;
+}
+`;
+}
+
+export function makeTypes(feature: string, name: string): void {
+    const base = ensureFeatureExists(feature, 'types');
+    const filePath = path.join(base, `${name}.types.ts`);
+
+    if (fileExists(filePath)) {
+        console.warn(`⚠️  Skipping "${name}.types.ts" — already exists`);
+        return;
+    }
+
+    writeFileSafe(filePath, renderTypes(name));
+    console.log(`✅ Types for "${name}" created at ${filePath}`);
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { Command } from 'commander';
 import { makeFeature } from './commands/feature';
 import { makeComponent } from './commands/component';
 import { makeHook } from './commands/hook';
@@ -6,70 +7,120 @@ import { makeService } from './commands/service';
 import { makeSchema } from './commands/schema';
 import { makeRepository } from './commands/repository';
 import { makeContainer } from './commands/container';
+import { makeTypes } from './commands/types';
 
-const [,, command, feature, name] = process.argv;
+const program = new Command();
 
-if (!command || !feature) {
-    console.error('Usage: domain-driver <command> [options]');
-    process.exit(1);
-}
+program
+    .name('domain-driver')
+    .description('CLI scaffolding tool for domain-driven development in Next.js')
+    .version('0.1.0');
 
-switch (command) {
-    case 'make:feature':
-        const all = process.argv.includes('-a') || process.argv.includes('-A');
-        makeFeature(feature, all).then(() => {});
-        break;
+program
+    .command('make:feature <name>')
+    .description('Scaffold a full feature folder structure')
+    .option('-a, --all', 'Scaffold all files inside each folder')
+    .action(async (name: string, options: { all?: boolean }) => {
+        try {
+            await makeFeature(name, options.all ?? false);
+        } catch (error: unknown) {
+            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: string, name: string, type: string) => {
+        try {
+            const componentType = type === 'server' ? 'server' : 'client';
+            makeComponent(feature, name, componentType);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`❌ ${message}`);
+            process.exit(1);
+        }
+    });
 
-    case 'make:component':
-        if (!name) {
-            console.error('Usage: domain-driver make:component <feature> <name> [client|server]');
+program
+    .command('make:container <feature> <name>')
+    .description('Scaffold a smart container component inside an existing feature')
+    .action((feature: string, name: string) => {
+        try {
+            makeContainer(feature, name);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`❌ ${message}`);
             process.exit(1);
         }
-        const type = (process.argv[5] as 'client' | 'server') || 'client';
-        makeComponent(feature, name, type);
-        break;
+    });
 
-    case 'make:hook':
-        if (!name) {
-            console.error('Usage: domain-driver make:hook <feature> <name>');
+program
+    .command('make:hook <feature> <name>')
+    .description('Scaffold a custom hook inside an existing feature')
+    .action((feature: string, name: string) => {
+        try {
+            makeHook(feature, name);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`❌ ${message}`);
             process.exit(1);
         }
-        makeHook(feature, name);
-        break;
+    });
 
-    case 'make:service':
-        if (!name) {
-            console.error('Usage: domain-driver make:service <feature> <name>');
+program
+    .command('make:service <feature> <name>')
+    .description('Scaffold single-responsibility service files inside an existing feature')
+    .action((feature: string, name: string) => {
+        try {
+            makeService(feature, name);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`❌ ${message}`);
             process.exit(1);
         }
-        makeService(feature, name);
-        break;
+    });
 
-    case 'make:schema':
-        if (!name) {
-            console.error('Usage: domain-driver make:schema <feature> <name>');
+program
+    .command('make:repository <feature> <name>')
+    .description('Scaffold single-responsibility repository files inside an existing feature')
+    .action((feature: string, name: string) => {
+        try {
+            makeRepository(feature, name);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`❌ ${message}`);
             process.exit(1);
         }
-        makeSchema(feature, name);
-        break;
+    });
 
-    case 'make:repository':
-        if (!name) {
-            console.error('Usage: domain-driver make:repository <feature> <name>');
+program
+    .command('make:schema <feature> <name>')
+    .description('Scaffold Zod schemas for create and update operations')
+    .action((feature: string, name: string) => {
+        try {
+            makeSchema(feature, name);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`❌ ${message}`);
             process.exit(1);
         }
-        makeRepository(feature, name);
-        break;
+    });
 
-    case 'make:container':
-        if (!name) {
-            console.error('Usage: domain-driver make:container <feature> <name>');
+program
+    .command('make:types <feature> <name>')
+    .description('Scaffold a types file inside an existing feature')
+    .action((feature: string, name: string) => {
+        try {
+            makeTypes(feature, name);
+        } catch (error: unknown) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.error(`❌ ${message}`);
             process.exit(1);
         }
-        makeContainer(feature, name);
-        break;
+    });
 
-    default:
-        console.error(`Unknown command: ${command}`);
-        process.exit(1);
-}
+program.parse();

package/src/utils.ts

@@ -0,0 +1,115 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export function toPascalCase(name: string): string {
+    return name
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+
+export function featureBasePath(feature: string): string {
+    return path.join(process.cwd(), 'app', feature);
+}
+
+export function ensureFeatureExists(feature: string, subdir: string): string {
+    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;
+}
+
+export function writeFileSafe(filePath: string, content: string): void {
+    try {
+        fs.writeFileSync(filePath, content);
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to write ${filePath}: ${message}`);
+    }
+}
+
+export function mkdirSafe(dirPath: string): void {
+    try {
+        fs.mkdirSync(dirPath, { recursive: true });
+    } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        throw new Error(`Failed to create directory ${dirPath}: ${message}`);
+    }
+}
+
+export function fileExists(filePath: string): boolean {
+    return fs.existsSync(filePath);
+}
+
+interface AliasConfig {
+    alias: string | null;
+    appDir: string;
+}
+
+let cachedAlias: AliasConfig | undefined;
+
+export function detectAlias(): AliasConfig {
+    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 as string[];
+                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;
+}
+
+export function resetAliasCache(): void {
+    cachedAlias = undefined;
+}
+
+export function resolveImport(fromFeature: string, relativePath: string, fromRoot: boolean = false): string {
+    const { alias } = detectAlias();
+
+    if (alias) {
+        return `${alias}app/${fromFeature}/${relativePath}`;
+    }
+
+    return fromRoot ? `./${relativePath}` : `../${relativePath}`;
+}

package/tsconfig.json

@@ -9,5 +9,5 @@
     "types": ["node"]
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
+  "exclude": ["node_modules", "dist", "src/**/__tests__/**"]
 }

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        include: ['src/**/__tests__/**/*.test.ts'],
+    },
+});