domain-driver 0.1.0 → 0.3.0

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

@@ -1,137 +0,0 @@
-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 { makeComponent } from '../component';
-import { makeContainer } from '../container';
-import { makeHook } from '../hook';
-import { makeService } from '../service';
-import { makeRepository } from '../repository';
-import { makeSchema } from '../schema';
-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('individual commands on existing feature', () => {
-    beforeEach(async () => {
-        originalCwd = process.cwd();
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dd-individual-'));
-        process.chdir(testDir);
-        resetAliasCache();
-        await makeFeature('test-feature', false);
-    });
-    afterEach(cleanup);
-
-    it('make:component creates client component by default', () => {
-        makeComponent('test-feature', 'MyButton', 'client');
-        const content = fs.readFileSync(
-            path.join(testDir, 'app/test-feature/components/client/MyButton.tsx'),
-            'utf-8'
-        );
-        expect(content).toContain("'use client'");
-        expect(content).toContain('export default function MyButton');
-        expect(content).toContain('interface MyButtonProps');
-    });
-
-    it('make:component creates server component', () => {
-        makeComponent('test-feature', 'DataTable', 'server');
-        const content = fs.readFileSync(
-            path.join(testDir, 'app/test-feature/components/server/DataTable.tsx'),
-            'utf-8'
-        );
-        expect(content).not.toContain("'use client'");
-        expect(content).toContain('export default function DataTable');
-    });
-
-    it('make:component throws if component already exists', () => {
-        makeComponent('test-feature', 'MyButton', 'client');
-        expect(() => makeComponent('test-feature', 'MyButton', 'client')).toThrow('already exists');
-    });
-
-    it('make:container creates container', () => {
-        makeContainer('test-feature', 'TestContainer');
-        const content = fs.readFileSync(
-            path.join(testDir, 'app/test-feature/containers/TestContainer.tsx'),
-            'utf-8'
-        );
-        expect(content).toContain("'use client'");
-        expect(content).toContain('export default function TestContainer');
-    });
-
-    it('make:hook creates hook file', () => {
-        makeHook('test-feature', 'useTest');
-        const content = fs.readFileSync(
-            path.join(testDir, 'app/test-feature/hooks/useTest.ts'),
-            'utf-8'
-        );
-        expect(content).toContain('export function useTest');
-        expect(content).toContain('useState');
-    });
-
-    it('make:service creates 5 service files', () => {
-        makeService('test-feature', 'TestEntity');
-        const base = path.join(testDir, 'app/test-feature/services');
-        expect(fs.existsSync(path.join(base, 'ListTestEntity.service.ts'))).toBe(true);
-        expect(fs.existsSync(path.join(base, 'ShowTestEntity.service.ts'))).toBe(true);
-        expect(fs.existsSync(path.join(base, 'CreateTestEntity.service.ts'))).toBe(true);
-        expect(fs.existsSync(path.join(base, 'UpdateTestEntity.service.ts'))).toBe(true);
-        expect(fs.existsSync(path.join(base, 'DeleteTestEntity.service.ts'))).toBe(true);
-    });
-
-    it('make:service skips existing files', () => {
-        makeService('test-feature', 'TestEntity');
-        expect(() => makeService('test-feature', 'TestEntity')).not.toThrow();
-    });
-
-    it('make:repository creates 5 repository files', () => {
-        makeRepository('test-feature', 'TestEntity');
-        const base = path.join(testDir, 'app/test-feature/repositories');
-        expect(fs.existsSync(path.join(base, 'ListTestEntity.repository.ts'))).toBe(true);
-        expect(fs.existsSync(path.join(base, 'ShowTestEntity.repository.ts'))).toBe(true);
-        expect(fs.existsSync(path.join(base, 'CreateTestEntity.repository.ts'))).toBe(true);
-        expect(fs.existsSync(path.join(base, 'UpdateTestEntity.repository.ts'))).toBe(true);
-        expect(fs.existsSync(path.join(base, 'DeleteTestEntity.repository.ts'))).toBe(true);
-    });
-
-    it('make:repository generates proper fetch calls', () => {
-        makeRepository('test-feature', 'TestEntity');
-        const content = fs.readFileSync(
-            path.join(testDir, 'app/test-feature/repositories/CreateTestEntity.repository.ts'),
-            'utf-8'
-        );
-        expect(content).toContain("fetch('/api/test-feature'");
-        expect(content).toContain("method: 'POST'");
-        expect(content).toContain("'Content-Type': 'application/json'");
-    });
-
-    it('make:schema creates Create and Update schemas', () => {
-        makeSchema('test-feature', 'TestEntity');
-        const base = path.join(testDir, 'app/test-feature/schemas');
-
-        const create = fs.readFileSync(path.join(base, 'CreateTestEntity.schema.ts'), 'utf-8');
-        expect(create).toContain("import { z } from 'zod'");
-        expect(create).toContain('CreateTestEntity');
-
-        const update = fs.readFileSync(path.join(base, 'UpdateTestEntity.schema.ts'), 'utf-8');
-        expect(update).toContain('id: z.string()');
-    });
-
-    it('throws when feature does not exist', () => {
-        expect(() => makeComponent('nonexistent', 'Foo', 'client')).toThrow('does not exist');
-        expect(() => makeHook('nonexistent', 'useFoo')).toThrow('does not exist');
-        expect(() => makeService('nonexistent', 'Foo')).toThrow('does not exist');
-        expect(() => makeRepository('nonexistent', 'Foo')).toThrow('does not exist');
-        expect(() => makeSchema('nonexistent', 'Foo')).toThrow('does not exist');
-        expect(() => makeContainer('nonexistent', 'FooContainer')).toThrow('does not exist');
-    });
-});

package/src/commands/component.ts

@@ -1,33 +0,0 @@
-import * as path from 'path';
-import { ensureFeatureExists, writeFileSafe, fileExists } from '../utils';
-
-type ComponentType = 'client' | 'server';
-
-function renderComponent(name: string, type: ComponentType): string {
-    const directive = type === 'client' ? "'use client';\n\n" : '';
-
-    return `${directive}interface ${name}Props {
-  id: string;
-}
-
-export default function ${name}({ id }: ${name}Props) {
-  return (
-    <div>
-      <h1>${name}</h1>
-    </div>
-  );
-}
-`;
-}
-
-export function makeComponent(feature: string, name: string, type: ComponentType = 'client'): void {
-    const base = ensureFeatureExists(feature, `components/${type}`);
-    const filePath = path.join(base, `${name}.tsx`);
-
-    if (fileExists(filePath)) {
-        throw new Error(`Component "${name}" already exists at ${filePath}`);
-    }
-
-    writeFileSafe(filePath, renderComponent(name, type));
-    console.log(`✅ Component "${name}" created at ${filePath}`);
-}

package/src/commands/container.ts

@@ -1,42 +0,0 @@
-import * as path from 'path';
-import { ensureFeatureExists, writeFileSafe, fileExists, resolveImport } from '../utils';
-
-function renderContainer(containerName: string, name: string, feature: string): string {
-    const hookName = `use${name}`;
-    const hookPath = resolveImport(feature, `hooks/${hookName}`);
-    const componentPath = resolveImport(feature, `components/client/${name}`);
-
-    return `'use client';
-
-import { ${hookName} } from '${hookPath}';
-import ${name} 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) => (
-        <${name} key={item.id} {...item} />
-      ))}
-    </div>
-  );
-}
-`;
-}
-
-export function makeContainer(feature: string, name: string, pascalName?: string): void {
-    const base = ensureFeatureExists(feature, 'containers');
-    const filePath = path.join(base, `${name}.tsx`);
-
-    if (fileExists(filePath)) {
-        throw new Error(`Container "${name}" already exists at ${filePath}`);
-    }
-
-    const entityName = pascalName ?? name.replace(/Container$/, '');
-    writeFileSafe(filePath, renderContainer(name, entityName, feature));
-    console.log(`✅ Container "${name}" created at ${filePath}`);
-}

package/src/commands/feature.ts

@@ -1,74 +0,0 @@
-import * as path from 'path';
-import { toPascalCase, featureBasePath, writeFileSafe, mkdirSafe, fileExists, resolveImport } from '../utils';
-import { makeComponent } from './component';
-import { makeHook } from './hook';
-import { makeService } from './service';
-import { makeRepository } from './repository';
-import { makeSchema } from './schema';
-import { makeContainer } from './container';
-import { makeTypes } from './types';
-
-const FEATURE_DIRS = [
-    'components/server',
-    'components/client',
-    'containers',
-    'hooks',
-    'services',
-    'repositories',
-    'schemas',
-    'types',
-];
-
-function renderPage(name: string, pascalName: string): string {
-    const containerPath = resolveImport(name, `containers/${pascalName}Container`, true);
-
-    return `import ${pascalName}Container from '${containerPath}';
-
-export default function ${pascalName}Page() {
-  return (
-    <div>
-      <${pascalName}Container />
-    </div>
-  );
-}
-`;
-}
-
-export async function makeFeature(name: string, all: boolean = false): Promise<void> {
-    const base = featureBasePath(name);
-    const pascalName = toPascalCase(name);
-
-    if (fileExists(base)) {
-        throw new Error(`Feature "${name}" already exists at ${base}`);
-    }
-
-    for (const dir of FEATURE_DIRS) {
-        mkdirSafe(path.join(base, dir));
-        if (!all) {
-            writeFileSafe(path.join(base, dir, '.gitkeep'), '');
-        }
-    }
-
-    if (all) {
-        writeFileSafe(path.join(base, 'page.tsx'), renderPage(name, pascalName));
-    } else {
-        writeFileSafe(
-            path.join(base, 'page.tsx'),
-            `export default function ${pascalName}Page() {\n  return (\n    <div>\n      <h1>${pascalName}</h1>\n    </div>\n  );\n}\n`
-        );
-    }
-
-    console.log(`✅ Feature "${name}" scaffolded at ${base}`);
-
-    if (all) {
-        makeTypes(name, pascalName);
-        makeSchema(name, pascalName);
-        makeRepository(name, pascalName);
-        makeService(name, pascalName);
-        makeHook(name, `use${pascalName}`, pascalName);
-        makeComponent(name, pascalName, 'client');
-        makeContainer(name, `${pascalName}Container`, pascalName);
-
-        console.log(`✅ All files scaffolded for "${name}"`);
-    }
-}

package/src/commands/repository.ts

@@ -1,95 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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,126 +0,0 @@
-#!/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 program = new 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: 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();