servcraft 0.2.0 → 0.3.1

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

@@ -0,0 +1,139 @@
+export function integrationTestTemplate(
+  name: string,
+  pascalName: string,
+  camelName: string
+): string {
+  return `import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import { build } from '../../app.js';
+import { FastifyInstance } from 'fastify';
+import { prisma } from '../../lib/prisma.js';
+
+describe('${pascalName} Integration Tests', () => {
+  let app: FastifyInstance;
+
+  beforeAll(async () => {
+    app = await build();
+    await app.ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+    await prisma.$disconnect();
+  });
+
+  beforeEach(async () => {
+    // Clean up test data
+    // await prisma.${camelName}.deleteMany();
+  });
+
+  describe('Full CRUD workflow', () => {
+    it('should create, read, update, and delete a ${camelName}', async () => {
+      // Create
+      const createResponse = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {
+          // TODO: Add required fields
+        },
+      });
+
+      expect(createResponse.statusCode).toBe(201);
+      const created = createResponse.json().data;
+      expect(created.id).toBeDefined();
+
+      // Read
+      const readResponse = await app.inject({
+        method: 'GET',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(readResponse.statusCode).toBe(200);
+      const read = readResponse.json().data;
+      expect(read.id).toBe(created.id);
+
+      // Update
+      const updateResponse = await app.inject({
+        method: 'PUT',
+        url: \`/${name}/\${created.id}\`,
+        payload: {
+          // TODO: Add fields to update
+        },
+      });
+
+      expect(updateResponse.statusCode).toBe(200);
+      const updated = updateResponse.json().data;
+      expect(updated.id).toBe(created.id);
+
+      // Delete
+      const deleteResponse = await app.inject({
+        method: 'DELETE',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(deleteResponse.statusCode).toBe(204);
+
+      // Verify deletion
+      const verifyResponse = await app.inject({
+        method: 'GET',
+        url: \`/${name}/\${created.id}\`,
+      });
+
+      expect(verifyResponse.statusCode).toBe(404);
+    });
+  });
+
+  describe('List and pagination', () => {
+    it('should list ${name} with pagination', async () => {
+      // Create multiple ${name}
+      const count = 5;
+      for (let i = 0; i < count; i++) {
+        await app.inject({
+          method: 'POST',
+          url: '/${name}',
+          payload: {
+            // TODO: Add required fields
+          },
+        });
+      }
+
+      // Test pagination
+      const response = await app.inject({
+        method: 'GET',
+        url: '/${name}?page=1&limit=3',
+      });
+
+      expect(response.statusCode).toBe(200);
+      const result = response.json();
+      expect(result.data).toBeDefined();
+      expect(result.data.length).toBeLessThanOrEqual(3);
+      expect(result.total).toBeGreaterThanOrEqual(count);
+    });
+  });
+
+  describe('Validation', () => {
+    it('should validate required fields on create', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {},
+      });
+
+      expect(response.statusCode).toBe(400);
+      expect(response.json()).toHaveProperty('error');
+    });
+
+    it('should validate data types', async () => {
+      const response = await app.inject({
+        method: 'POST',
+        url: '/${name}',
+        payload: {
+          // TODO: Add invalid field types
+        },
+      });
+
+      expect(response.statusCode).toBe(400);
+    });
+  });
+});
+`;
+}

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