domain-driver 0.0.4 → 0.1.0

package/src/commands/hook.ts

@@ -0,0 +1,122 @@
+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')}';
+
+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();
+
+export function ${hookName}() {
+  const [items, setItems] = useState<${name}[]>([]);
+  const [selected, setSelected] = useState<${name} | null>(null);
+  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) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await showService.handle(id);
+      setSelected(data);
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : 'Failed to fetch');
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const create = useCallback(async (data: Create${name}) => {
+    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);
+    }
+  }, []);
+
+  const update = useCallback(async (id: string, data: Update${name}) => {
+    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);
+    }
+  }, []);
+
+  const remove = useCallback(async (id: string) => {
+    setLoading(true);
+    setError(null);
+    try {
+      await deleteService.handle(id);
+      setItems((prev) => prev.filter((item) => item.id !== id));
+    } catch (err: unknown) {
+      setError(err instanceof Error ? err.message : 'Failed to delete');
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    fetchAll();
+  }, [fetchAll]);
+
+  return { items, selected, loading, error, fetchAll, fetchOne, create, update, remove };
+}
+`;
+}
+
+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/src/commands/repository.ts

@@ -0,0 +1,95 @@
+import * as path from 'path';
+import { ensureFeatureExists, writeFileSafe, fileExists, resolveImport } from '../utils';
+
+type RepositoryAction = 'List' | 'Create' | 'Update' | 'Delete' | 'Show';
+
+const REPOSITORY_ACTIONS: RepositoryAction[] = ['List', 'Create', 'Update', 'Delete', 'Show'];
+
+function renderRepository(action: RepositoryAction, name: string, feature: string): string {
+    const typePath = resolveImport(feature, `types/${name}.types`);
+    const schemaPath = (op: string) => resolveImport(feature, `schemas/${op}${name}.schema`);
+
+    switch (action) {
+        case 'List':
+            return `import { ${name} } from '${typePath}';
+
+export class List${name}Repository {
+  async handle(): Promise<${name}[]> {
+    const response = await fetch('/api/${feature}');
+    if (!response.ok) throw new Error('Failed to fetch ${name} list');
+    return response.json();
+  }
+}
+`;
+        case 'Show':
+            return `import { ${name} } from '${typePath}';
+
+export class Show${name}Repository {
+  async handle(id: string): Promise<${name}> {
+    const response = await fetch(\`/api/${feature}/\${id}\`);
+    if (!response.ok) throw new Error('Failed to fetch ${name}');
+    return response.json();
+  }
+}
+`;
+        case 'Create':
+            return `import { ${name} } from '${typePath}';
+import { Create${name} } from '${schemaPath('Create')}';
+
+export class Create${name}Repository {
+  async handle(data: Create${name}): Promise<${name}> {
+    const response = await fetch('/api/${feature}', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+    if (!response.ok) throw new Error('Failed to create ${name}');
+    return response.json();
+  }
+}
+`;
+        case 'Update':
+            return `import { ${name} } from '${typePath}';
+import { Update${name} } from '${schemaPath('Update')}';
+
+export class Update${name}Repository {
+  async handle(id: string, data: Update${name}): Promise<${name}> {
+    const response = await fetch(\`/api/${feature}/\${id}\`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(data),
+    });
+    if (!response.ok) throw new Error('Failed to update ${name}');
+    return response.json();
+  }
+}
+`;
+        case 'Delete':
+            return `export class Delete${name}Repository {
+  async handle(id: string): Promise<void> {
+    const response = await fetch(\`/api/${feature}/\${id}\`, {
+      method: 'DELETE',
+    });
+    if (!response.ok) throw new Error('Failed to delete ${name}');
+  }
+}
+`;
+    }
+}
+
+export function makeRepository(feature: string, name: string): void {
+    const base = ensureFeatureExists(feature, 'repositories');
+
+    for (const action of REPOSITORY_ACTIONS) {
+        const filePath = path.join(base, `${action}${name}.repository.ts`);
+
+        if (fileExists(filePath)) {
+            console.warn(`⚠️  Skipping "${action}${name}.repository.ts" — already exists`);
+            continue;
+        }
+
+        writeFileSafe(filePath, renderRepository(action, name, feature));
+    }
+
+    console.log(`✅ Repositories for "${name}" created at ${base}`);
+}

package/src/commands/schema.ts

@@ -0,0 +1,47 @@
+import * as path from 'path';
+import { ensureFeatureExists, writeFileSafe, fileExists } from '../utils';
+
+type SchemaAction = 'Create' | 'Update';
+
+const SCHEMA_ACTIONS: SchemaAction[] = ['Create', 'Update'];
+
+function renderSchema(action: SchemaAction, name: string): string {
+    switch (action) {
+        case 'Create':
+            return `import { z } from 'zod';
+
+export const Create${name}Schema = z.object({
+  // add create fields here
+});
+
+export type Create${name} = z.infer<typeof Create${name}Schema>;
+`;
+        case 'Update':
+            return `import { z } from 'zod';
+
+export const Update${name}Schema = z.object({
+  id: z.string(),
+  // add update fields here
+});
+
+export type Update${name} = z.infer<typeof Update${name}Schema>;
+`;
+    }
+}
+
+export function makeSchema(feature: string, name: string): void {
+    const base = ensureFeatureExists(feature, 'schemas');
+
+    for (const action of SCHEMA_ACTIONS) {
+        const filePath = path.join(base, `${action}${name}.schema.ts`);
+
+        if (fileExists(filePath)) {
+            console.warn(`⚠️  Skipping "${action}${name}.schema.ts" — already exists`);
+            continue;
+        }
+
+        writeFileSafe(filePath, renderSchema(action, name));
+    }
+
+    console.log(`✅ Schemas for "${name}" created at ${base}`);
+}

package/src/commands/service.ts

@@ -0,0 +1,93 @@
+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, 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 `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 `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 `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 `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 `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): void {
+    const base = ensureFeatureExists(feature, 'services');
+
+    for (const action of SERVICE_ACTIONS) {
+        const filePath = path.join(base, `${action}${name}.service.ts`);
+
+        if (fileExists(filePath)) {
+            console.warn(`⚠️  Skipping "${action}${name}.service.ts" — already exists`);
+            continue;
+        }
+
+        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,16 +1,126 @@
 #!/usr/bin/env node
+import { Command } from 'commander';
 import { makeFeature } from './commands/feature';
+import { makeComponent } from './commands/component';
+import { makeHook } from './commands/hook';
+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, name] = process.argv;
+const program = new Command();
 
-if (!command || !name) {
-    console.error('Usage: domain-driver make:feature <name>');
-    process.exit(1);
-}
+program
+    .name('domain-driver')
+    .description('CLI scaffolding tool for domain-driven development in Next.js')
+    .version('0.1.0');
 
-if (command === 'make:feature') {
-    makeFeature(name);
-} else {
-    console.error(`Unknown command: ${command}`);
-    process.exit(1);
-}
+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);
+        }
+    });
+
+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);
+        }
+    });
+
+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);
+        }
+    });
+
+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);
+        }
+    });
+
+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);
+        }
+    });
+
+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);
+        }
+    });
+
+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);
+        }
+    });
+
+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'],
+    },
+});