domain-driver 0.0.4 → 0.1.0

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

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

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

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

@@ -0,0 +1,42 @@
+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,5 +1,12 @@
-import * as fs from 'fs';
 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',
@@ -9,34 +16,59 @@ const FEATURE_DIRS = [
     'services',
     'repositories',
     'schemas',
+    'types',
 ];
 
-function renderTemplate(name: string): string {
-    const componentName = name
-        .split('-')
-        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-        .join('');
+function renderPage(name: string, pascalName: string): string {
+    const containerPath = resolveImport(name, `containers/${pascalName}Container`, true);
 
-    return `export default function ${componentName}Page() {
+    return `import ${pascalName}Container from '${containerPath}';
+
+export default function ${pascalName}Page() {
   return (
     <div>
-      <h1>${componentName}</h1>
+      <${pascalName}Container />
     </div>
   );
 }
 `;
 }
 
-export async function makeFeature(name: string) {
-    const base = path.join(process.cwd(), 'app', name);
+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) {
-        fs.mkdirSync(path.join(base, dir), { recursive: true });
-        fs.writeFileSync(path.join(base, dir, '.gitkeep'), '');
+        mkdirSafe(path.join(base, dir));
+        if (!all) {
+            writeFileSafe(path.join(base, dir, '.gitkeep'), '');
+        }
     }
 
-    const page = renderTemplate(name);
-    fs.writeFileSync(path.join(base, 'page.tsx'), page);
+    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}"`);
+    }
+}