servcraft 0.2.0 → 0.4.2

package/src/cli/templates/service-test.ts

@@ -0,0 +1,100 @@
+export function serviceTestTemplate(name: string, pascalName: string, camelName: string): string {
+  return `import { describe, it, expect, beforeEach } from 'vitest';
+import { ${pascalName}Service } from '../${name}.service.js';
+
+describe('${pascalName}Service', () => {
+  let service: ${pascalName}Service;
+
+  beforeEach(() => {
+    service = new ${pascalName}Service();
+  });
+
+  describe('getAll', () => {
+    it('should return all ${name}', async () => {
+      const result = await service.getAll();
+
+      expect(result).toBeDefined();
+      expect(Array.isArray(result)).toBe(true);
+    });
+
+    it('should apply pagination', async () => {
+      const result = await service.getAll({ page: 1, limit: 10 });
+
+      expect(result).toBeDefined();
+      expect(result.length).toBeLessThanOrEqual(10);
+    });
+  });
+
+  describe('getById', () => {
+    it('should return a ${camelName} by id', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const result = await service.getById(id);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(id);
+    });
+
+    it('should return null for non-existent id', async () => {
+      const result = await service.getById('999999');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new ${camelName}', async () => {
+      const data = {
+        // TODO: Add required fields
+      };
+
+      const result = await service.create(data);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBeDefined();
+    });
+
+    it('should throw error for invalid data', async () => {
+      await expect(service.create({} as any)).rejects.toThrow();
+    });
+  });
+
+  describe('update', () => {
+    it('should update a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const updates = {
+        // TODO: Add fields to update
+      };
+
+      const result = await service.update(id, updates);
+
+      expect(result).toBeDefined();
+      expect(result.id).toBe(id);
+    });
+
+    it('should return null for non-existent id', async () => {
+      const result = await service.update('999999', {});
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a ${camelName}', async () => {
+      // TODO: Create test ${camelName} first
+      const id = '1';
+      const result = await service.delete(id);
+
+      expect(result).toBe(true);
+    });
+
+    it('should return false for non-existent id', async () => {
+      const result = await service.delete('999999');
+
+      expect(result).toBe(false);
+    });
+  });
+});
+`;
+}

package/src/cli/utils/template-loader.ts

@@ -0,0 +1,80 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getProjectRoot } from './helpers.js';
+
+/**
+ * Template loader that checks for custom templates in priority order:
+ * 1. Project templates (.servcraft/templates/)
+ * 2. User templates (~/.servcraft/templates/)
+ * 3. Built-in templates (fallback)
+ */
+
+export type TemplateType =
+  | 'controller'
+  | 'service'
+  | 'repository'
+  | 'types'
+  | 'schemas'
+  | 'routes'
+  | 'module-index'
+  | 'controller-test'
+  | 'service-test'
+  | 'integration-test';
+
+interface TemplateFunction {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: (...args: any[]) => string;
+}
+
+/**
+ * Load a custom template if available, otherwise return null
+ */
+export async function loadCustomTemplate(
+  templateType: TemplateType
+): Promise<TemplateFunction | null> {
+  const projectRoot = getProjectRoot();
+  const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+
+  const locations = [
+    path.join(projectRoot, '.servcraft', 'templates', `${templateType}.ts`),
+    path.join(homeDir, '.servcraft', 'templates', `${templateType}.ts`),
+  ];
+
+  for (const location of locations) {
+    try {
+      await fs.access(location);
+      // Template file exists, dynamically import it
+      const templateModule = (await import(`file://${location}`)) as TemplateFunction;
+
+      // Look for the template function (e.g., controllerTemplate, serviceTemplate)
+      const functionName = `${templateType.replace(/-/g, '')}Template`;
+
+      if (templateModule[functionName]) {
+        return templateModule;
+      }
+    } catch {
+      // File doesn't exist or import failed, try next location
+      continue;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get template function with fallback to built-in
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export async function getTemplate<T extends (...args: any[]) => string>(
+  templateType: TemplateType,
+  builtInTemplate: T
+): Promise<T> {
+  const customTemplate = await loadCustomTemplate(templateType);
+
+  if (customTemplate) {
+    const functionName = `${templateType.replace(/-/g, '')}Template`;
+    return customTemplate[functionName] as T;
+  }
+
+  return builtInTemplate;
+}

package/tests/cli/add.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+
+describe('servcraft add', () => {
+  const cliPath = './dist/cli/index.js';
+
+  it('should show error when not in a servcraft project', () => {
+    try {
+      execSync(`node ${cliPath} add auth`, { encoding: 'utf-8', stdio: 'pipe' });
+    } catch (err) {
+      const error = err as { stdout?: string; stderr?: string };
+      const output = error.stdout || error.stderr || '';
+      expect(output).toContain('Failed to validate project');
+    }
+  });
+
+  it('should show error for invalid module name', () => {
+    try {
+      execSync(`node ${cliPath} add invalid-module-xyz`, { encoding: 'utf-8', stdio: 'pipe' });
+    } catch (err) {
+      const error = err as { stdout?: string; stderr?: string };
+      const output = error.stdout || error.stderr || '';
+      expect(output).toContain('Module "invalid-module-xyz" not found');
+    }
+  });
+
+  it('should show help with --help flag', () => {
+    const output = execSync(`node ${cliPath} add --help`, { encoding: 'utf-8' });
+    expect(output).toContain('Add a pre-built module');
+    expect(output).toContain('--dry-run');
+  });
+});

package/tests/cli/completion.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+
+describe('servcraft completion', () => {
+  const cliPath = './dist/cli/index.js';
+
+  it('should generate bash completion script', () => {
+    const output = execSync(`node ${cliPath} completion bash`, { encoding: 'utf-8' });
+    expect(output).toContain('_servcraft_completions');
+    expect(output).toContain('complete -F _servcraft_completions servcraft');
+  });
+
+  it('should generate zsh completion script', () => {
+    const output = execSync(`node ${cliPath} completion zsh`, { encoding: 'utf-8' });
+    expect(output).toContain('#compdef servcraft');
+    expect(output).toContain('_servcraft');
+  });
+
+  it('should show error for unsupported shell', () => {
+    try {
+      execSync(`node ${cliPath} completion fish`, { encoding: 'utf-8', stdio: 'pipe' });
+    } catch (err) {
+      const error = err as { stdout?: string; stderr?: string };
+      const output = error.stdout || error.stderr || '';
+      expect(output).toContain('Unsupported shell: fish');
+      expect(output).toContain('Supported shells: bash, zsh');
+    }
+  });
+
+  it('should show help with --help flag', () => {
+    const output = execSync(`node ${cliPath} completion --help`, { encoding: 'utf-8' });
+    expect(output).toContain('Generate shell completion scripts');
+    expect(output).toContain('Shell type (bash or zsh)');
+  });
+});

package/tests/cli/doctor.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+
+describe('servcraft doctor', () => {
+  const cliPath = './dist/cli/index.js';
+
+  it('should run diagnostics', () => {
+    const output = execSync(`node ${cliPath} doctor`, { encoding: 'utf-8' });
+    expect(output).toContain('ServCraft Doctor');
+    expect(output).toContain('Node.js');
+    expect(output).toContain('package.json');
+  });
+
+  it('should check Node.js version', () => {
+    const output = execSync(`node ${cliPath} doctor`, { encoding: 'utf-8' });
+    expect(output).toMatch(/Node\.js.*v\d+\.\d+\.\d+/);
+  });
+
+  it('should display summary', () => {
+    const output = execSync(`node ${cliPath} doctor`, { encoding: 'utf-8' });
+    expect(output).toMatch(/\d+ passed/);
+  });
+});

package/tests/cli/dry-run.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect, afterAll } from 'vitest';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+describe('--dry-run option', () => {
+  const cliPath = './dist/cli/index.js';
+  const testDir = 'dry-test-' + Date.now();
+
+  afterAll(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should preview init without creating files', () => {
+    const output = execSync(`node ${cliPath} init ${testDir} --yes --dry-run`, {
+      encoding: 'utf-8',
+    });
+
+    expect(output).toContain('DRY RUN MODE');
+    expect(output).toContain('Dry Run - Preview of changes');
+    expect(output).toContain('package.json');
+    expect(output).toContain('Total operations');
+
+    // Check that package.json was not actually created
+    const pkgPath = path.join(testDir, 'package.json');
+    expect(fs.existsSync(pkgPath)).toBe(false);
+  });
+
+  it('should show file count in dry-run', () => {
+    const testName = 'test-app-' + Date.now();
+    const output = execSync(`node ${cliPath} init ${testName} --yes --dry-run`, {
+      encoding: 'utf-8',
+    });
+    expect(output).toMatch(/Total operations: \d+/);
+    expect(output).toMatch(/\d+ create/);
+  });
+});

package/tests/cli/errors.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+
+describe('error handling', () => {
+  const cliPath = './dist/cli/index.js';
+
+  it('should show helpful error for invalid module', () => {
+    try {
+      execSync(`node ${cliPath} add invalid-module-xyz`, { encoding: 'utf-8', stdio: 'pipe' });
+    } catch (err) {
+      const error = err as { stdout?: string; stderr?: string };
+      const output = error.stdout || error.stderr || '';
+      expect(output).toContain('Module "invalid-module-xyz" not found');
+      expect(output).toContain('Suggestions');
+      expect(output).toContain('servcraft list');
+    }
+  });
+
+  it('should show error with documentation link', () => {
+    try {
+      execSync(`node ${cliPath} add nonexistent`, { encoding: 'utf-8', stdio: 'pipe' });
+    } catch (err) {
+      const error = err as { stdout?: string; stderr?: string };
+      const output = error.stdout || error.stderr || '';
+      expect(output).toContain('Documentation:');
+      expect(output).toContain('github.com');
+    }
+  });
+});

package/tests/cli/generate.test.ts

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+
+describe('servcraft generate', () => {
+  const cliPath = './dist/cli/index.js';
+
+  it('should generate controller with dry-run', () => {
+    const uniqueName = 'testuser' + Date.now();
+    const output = execSync(`node ${cliPath} generate controller ${uniqueName} --dry-run`, {
+      encoding: 'utf-8',
+    });
+
+    expect(output).toContain('DRY RUN MODE');
+    expect(output).toContain(`${uniqueName}.controller.ts`);
+    expect(output).toContain('Total operations');
+  });
+
+  it('should generate service with dry-run', () => {
+    const uniqueName = 'testproduct' + Date.now();
+    const output = execSync(`node ${cliPath} g s ${uniqueName} --dry-run`, {
+      encoding: 'utf-8',
+    });
+
+    expect(output).toContain('DRY RUN MODE');
+    expect(output).toContain(`${uniqueName}.service.ts`);
+  });
+
+  it('should generate module with dry-run', () => {
+    const uniqueName = 'testorder' + Date.now();
+    const output = execSync(`node ${cliPath} g m ${uniqueName} --dry-run`, {
+      encoding: 'utf-8',
+    });
+
+    expect(output).toContain('DRY RUN MODE');
+    expect(output).toContain(`${uniqueName}.controller.ts`);
+    expect(output).toContain(`${uniqueName}.service.ts`);
+    expect(output).toContain(`${uniqueName}.routes.ts`);
+  });
+});

package/tests/cli/init.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { execSync } from 'child_process';
+import fs from 'fs';
+
+describe('servcraft init', () => {
+  const cliPath = './dist/cli/index.js';
+  const testProjects: string[] = [];
+
+  afterEach(() => {
+    testProjects.forEach((dir) => {
+      if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+      }
+    });
+    testProjects.length = 0;
+  });
+
+  it('should create project structure with --dry-run', () => {
+    const projectName = 'test-init-' + Date.now();
+
+    const output = execSync(`node ${cliPath} init ${projectName} --yes --dry-run`, {
+      encoding: 'utf-8',
+    });
+
+    expect(output).toContain('Servcraft Project Generator');
+    expect(output).toContain('package.json');
+    expect(output).toContain('src/');
+    expect(output).toContain('DRY RUN MODE');
+  });
+
+  it('should support --js flag with dry-run', () => {
+    const projectName = 'test-js-' + Date.now();
+
+    const output = execSync(`node ${cliPath} init ${projectName} --yes --js --dry-run`, {
+      encoding: 'utf-8',
+    });
+
+    expect(output).toContain('package.json');
+    expect(output).toContain('DRY RUN MODE');
+  });
+
+  it('should support --cjs flag with dry-run', () => {
+    const projectName = 'test-cjs-' + Date.now();
+
+    const output = execSync(`node ${cliPath} init ${projectName} --yes --cjs --dry-run`, {
+      encoding: 'utf-8',
+    });
+
+    expect(output).toContain('package.json');
+    expect(output).toContain('DRY RUN MODE');
+  });
+
+  it('should support --esm flag with dry-run', () => {
+    const projectName = 'test-esm-' + Date.now();
+
+    const output = execSync(`node ${cliPath} init ${projectName} --yes --esm --dry-run`, {
+      encoding: 'utf-8',
+    });
+
+    expect(output).toContain('package.json');
+    expect(output).toContain('module');
+  });
+});

package/tests/cli/list.test.ts

@@ -0,0 +1,25 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+
+describe('servcraft list', () => {
+  const cliPath = './dist/cli/index.js';
+
+  it('should display available modules', () => {
+    const output = execSync(`node ${cliPath} list`, { encoding: 'utf-8' });
+    expect(output).toContain('Available Modules');
+    expect(output).toContain('Core');
+    expect(output).toContain('Security');
+  });
+
+  it('should support --json output', () => {
+    const output = execSync(`node ${cliPath} list --json`, { encoding: 'utf-8' });
+    const data = JSON.parse(output);
+    expect(data).toHaveProperty('available');
+    expect(Array.isArray(data.available)).toBe(true);
+  });
+
+  it('should work with alias ls', () => {
+    const output = execSync(`node ${cliPath} ls`, { encoding: 'utf-8' });
+    expect(output).toContain('Available Modules');
+  });
+});

package/tests/cli/remove.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+
+describe('servcraft remove', () => {
+  const cliPath = './dist/cli/index.js';
+
+  it('should show error when not in a servcraft project', () => {
+    try {
+      execSync(`node ${cliPath} remove auth`, { encoding: 'utf-8', stdio: 'pipe' });
+    } catch (err) {
+      const error = err as { stdout?: string; stderr?: string };
+      const output = error.stdout || error.stderr || '';
+      expect(output).toContain('Failed to validate project');
+    }
+  });
+
+  it('should show help with --help flag', () => {
+    const output = execSync(`node ${cliPath} remove --help`, { encoding: 'utf-8' });
+    expect(output).toContain('Remove an installed module');
+    expect(output).toContain('--yes');
+    expect(output).toContain('--keep-env');
+  });
+
+  it('should work with alias rm', () => {
+    const output = execSync(`node ${cliPath} rm --help`, { encoding: 'utf-8' });
+    expect(output).toContain('Remove an installed module');
+  });
+});

package/tests/cli/update.test.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from 'vitest';
+import { execSync } from 'child_process';
+
+describe('servcraft update', () => {
+  const cliPath = './dist/cli/index.js';
+
+  it('should show error when not in a servcraft project', () => {
+    try {
+      execSync(`node ${cliPath} update`, { encoding: 'utf-8', stdio: 'pipe' });
+    } catch (err) {
+      const error = err as { stdout?: string; stderr?: string };
+      const output = error.stdout || error.stderr || '';
+      expect(output).toContain('Failed to validate project');
+    }
+  });
+
+  it('should show help with --help flag', () => {
+    const output = execSync(`node ${cliPath} update --help`, { encoding: 'utf-8' });
+    expect(output).toContain('Update installed modules');
+    expect(output).toContain('--check');
+    expect(output).toContain('--yes');
+  });
+
+  it('should support --check flag', () => {
+    try {
+      execSync(`node ${cliPath} update --check`, { encoding: 'utf-8', stdio: 'pipe' });
+    } catch (err) {
+      const error = err as { stdout?: string; stderr?: string };
+      const output = error.stdout || error.stderr || '';
+      // Either shows error (not in project) or check output
+      expect(output.length).toBeGreaterThan(0);
+    }
+  });
+});