@l4yercak3/cli 1.0.0

package/tests/detector-registry.test.js

@@ -0,0 +1,93 @@
+/**
+ * Tests for Detector Registry
+ */
+
+const registry = require('../src/detectors/registry');
+
+describe('Detector Registry', () => {
+  describe('detectProjectType', () => {
+    it('returns results object with expected structure', () => {
+      const result = registry.detectProjectType('/nonexistent/path');
+
+      expect(result).toHaveProperty('detected');
+      expect(result).toHaveProperty('confidence');
+      expect(result).toHaveProperty('metadata');
+      expect(result).toHaveProperty('allResults');
+      expect(Array.isArray(result.allResults)).toBe(true);
+    });
+
+    it('returns detected: null when no framework matches', () => {
+      const result = registry.detectProjectType('/nonexistent/path');
+
+      expect(result.detected).toBeNull();
+      expect(result.confidence).toBe(0);
+    });
+
+    it('includes all detector results in allResults', () => {
+      const result = registry.detectProjectType('/nonexistent/path');
+
+      expect(result.allResults.length).toBeGreaterThan(0);
+      expect(result.allResults[0]).toHaveProperty('detector');
+      expect(result.allResults[0]).toHaveProperty('priority');
+    });
+  });
+
+  describe('getDetector', () => {
+    it('returns nextjs detector by name', () => {
+      const detector = registry.getDetector('nextjs');
+
+      expect(detector).not.toBeNull();
+      expect(detector.name).toBe('nextjs');
+    });
+
+    it('returns null for unknown detector name', () => {
+      const detector = registry.getDetector('unknown-detector');
+
+      expect(detector).toBeNull();
+    });
+
+    it('returns null for empty name', () => {
+      const detector = registry.getDetector('');
+
+      expect(detector).toBeNull();
+    });
+  });
+
+  describe('getAllDetectors', () => {
+    it('returns array of detectors', () => {
+      const detectors = registry.getAllDetectors();
+
+      expect(Array.isArray(detectors)).toBe(true);
+      expect(detectors.length).toBeGreaterThan(0);
+    });
+
+    it('returns detectors sorted by priority (highest first)', () => {
+      const detectors = registry.getAllDetectors();
+
+      for (let i = 1; i < detectors.length; i++) {
+        expect(detectors[i - 1].priority).toBeGreaterThanOrEqual(detectors[i].priority);
+      }
+    });
+
+    it('each detector has required properties', () => {
+      const detectors = registry.getAllDetectors();
+
+      for (const detector of detectors) {
+        expect(detector).toHaveProperty('name');
+        expect(detector).toHaveProperty('priority');
+        expect(typeof detector.detect).toBe('function');
+      }
+    });
+  });
+
+  describe('detectors export', () => {
+    it('exports sorted detectors array', () => {
+      expect(Array.isArray(registry.detectors)).toBe(true);
+      expect(registry.detectors.length).toBeGreaterThan(0);
+    });
+
+    it('exported detectors match getAllDetectors', () => {
+      expect(registry.detectors).toEqual(registry.getAllDetectors());
+    });
+  });
+});

package/tests/env-generator.test.js

@@ -0,0 +1,278 @@
+/**
+ * Tests for Environment Generator
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const EnvGenerator = require('../src/generators/env-generator');
+
+describe('EnvGenerator', () => {
+  const mockProjectPath = '/test/project';
+  const mockEnvPath = path.join(mockProjectPath, '.env.local');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+    fs.writeFileSync.mockReturnValue(undefined);
+  });
+
+  describe('generate', () => {
+    it('creates basic env file with core config', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: [],
+        oauthProviders: [],
+      };
+
+      const result = EnvGenerator.generate(options);
+
+      expect(result).toBe(mockEnvPath);
+      expect(fs.writeFileSync).toHaveBeenCalled();
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('L4YERCAK3_API_KEY=test-api-key');
+      expect(writtenContent).toContain('L4YERCAK3_BACKEND_URL=https://backend.test.com');
+      expect(writtenContent).toContain('L4YERCAK3_ORGANIZATION_ID=org-123');
+      expect(writtenContent).toContain('NEXT_PUBLIC_L4YERCAK3_BACKEND_URL=https://backend.test.com');
+    });
+
+    it('adds Google OAuth variables when enabled', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: ['google'],
+      };
+
+      EnvGenerator.generate(options);
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('GOOGLE_CLIENT_ID=');
+      expect(writtenContent).toContain('GOOGLE_CLIENT_SECRET=');
+      expect(writtenContent).toContain('NEXTAUTH_URL=');
+      expect(writtenContent).toContain('NEXTAUTH_SECRET=');
+    });
+
+    it('adds Microsoft OAuth variables when enabled', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: ['microsoft'],
+      };
+
+      EnvGenerator.generate(options);
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('AZURE_CLIENT_ID=');
+      expect(writtenContent).toContain('AZURE_CLIENT_SECRET=');
+      expect(writtenContent).toContain('AZURE_TENANT_ID=');
+    });
+
+    it('adds GitHub OAuth variables when enabled', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: ['github'],
+      };
+
+      EnvGenerator.generate(options);
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('GITHUB_CLIENT_ID=');
+      expect(writtenContent).toContain('GITHUB_CLIENT_SECRET=');
+    });
+
+    it('adds Stripe variables when enabled', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['stripe'],
+        oauthProviders: [],
+      };
+
+      EnvGenerator.generate(options);
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=');
+      expect(writtenContent).toContain('STRIPE_SECRET_KEY=');
+      expect(writtenContent).toContain('STRIPE_WEBHOOK_SECRET=');
+    });
+
+    it('preserves existing env values', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`
+GOOGLE_CLIENT_ID=existing-google-id
+GOOGLE_CLIENT_SECRET=existing-google-secret
+CUSTOM_VAR=custom-value
+`);
+
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'new-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: ['google'],
+      };
+
+      EnvGenerator.generate(options);
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('GOOGLE_CLIENT_ID=existing-google-id');
+      expect(writtenContent).toContain('GOOGLE_CLIENT_SECRET=existing-google-secret');
+      expect(writtenContent).toContain('L4YERCAK3_API_KEY=new-api-key');
+    });
+
+    it('adds all OAuth providers when multiple selected', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: ['google', 'microsoft', 'github'],
+      };
+
+      EnvGenerator.generate(options);
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('GOOGLE_CLIENT_ID=');
+      expect(writtenContent).toContain('AZURE_CLIENT_ID=');
+      expect(writtenContent).toContain('GITHUB_CLIENT_ID=');
+    });
+  });
+
+  describe('readExistingEnv', () => {
+    it('returns empty object when file does not exist', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = EnvGenerator.readExistingEnv(mockEnvPath);
+
+      expect(result).toEqual({});
+    });
+
+    it('parses simple key=value pairs', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`
+API_KEY=test123
+SECRET=mysecret
+`);
+
+      const result = EnvGenerator.readExistingEnv(mockEnvPath);
+
+      expect(result).toEqual({
+        API_KEY: 'test123',
+        SECRET: 'mysecret',
+      });
+    });
+
+    it('ignores comments', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`
+# This is a comment
+API_KEY=test123
+# Another comment
+`);
+
+      const result = EnvGenerator.readExistingEnv(mockEnvPath);
+
+      expect(result).toEqual({
+        API_KEY: 'test123',
+      });
+    });
+
+    it('handles empty lines', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`
+API_KEY=test123
+
+SECRET=mysecret
+
+`);
+
+      const result = EnvGenerator.readExistingEnv(mockEnvPath);
+
+      expect(result).toEqual({
+        API_KEY: 'test123',
+        SECRET: 'mysecret',
+      });
+    });
+
+    it('handles read errors gracefully', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('Read failed');
+      });
+
+      const result = EnvGenerator.readExistingEnv(mockEnvPath);
+
+      expect(result).toEqual({});
+    });
+  });
+
+  describe('formatEnvFile', () => {
+    it('includes header comment', () => {
+      const envVars = {
+        L4YERCAK3_API_KEY: 'key',
+        L4YERCAK3_BACKEND_URL: 'url',
+        L4YERCAK3_ORGANIZATION_ID: 'org',
+        NEXT_PUBLIC_L4YERCAK3_BACKEND_URL: 'url',
+      };
+
+      const result = EnvGenerator.formatEnvFile(envVars);
+
+      expect(result).toContain('# L4YERCAK3 Configuration');
+      expect(result).toContain('# Auto-generated by @l4yercak3/cli');
+      expect(result).toContain('# DO NOT commit this file to git');
+    });
+
+    it('groups OAuth variables under OAuth section', () => {
+      const envVars = {
+        L4YERCAK3_API_KEY: 'key',
+        L4YERCAK3_BACKEND_URL: 'url',
+        L4YERCAK3_ORGANIZATION_ID: 'org',
+        NEXT_PUBLIC_L4YERCAK3_BACKEND_URL: 'url',
+        GOOGLE_CLIENT_ID: 'google-id',
+        GOOGLE_CLIENT_SECRET: 'google-secret',
+        NEXTAUTH_URL: 'http://localhost:3000',
+        NEXTAUTH_SECRET: 'secret',
+      };
+
+      const result = EnvGenerator.formatEnvFile(envVars);
+
+      expect(result).toContain('# OAuth Configuration');
+    });
+
+    it('groups Stripe variables under Stripe section', () => {
+      const envVars = {
+        L4YERCAK3_API_KEY: 'key',
+        L4YERCAK3_BACKEND_URL: 'url',
+        L4YERCAK3_ORGANIZATION_ID: 'org',
+        NEXT_PUBLIC_L4YERCAK3_BACKEND_URL: 'url',
+        NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY: 'pk_test',
+        STRIPE_SECRET_KEY: 'sk_test',
+        STRIPE_WEBHOOK_SECRET: 'whsec_test',
+      };
+
+      const result = EnvGenerator.formatEnvFile(envVars);
+
+      expect(result).toContain('# Stripe Configuration');
+    });
+  });
+});

package/tests/generators-index.test.js

@@ -0,0 +1,215 @@
+/**
+ * Tests for Generators Index (FileGenerator)
+ */
+
+const fs = require('fs');
+
+jest.mock('fs');
+
+const FileGenerator = require('../src/generators/index');
+
+describe('FileGenerator', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+    fs.mkdirSync.mockReturnValue(undefined);
+    fs.writeFileSync.mockReturnValue(undefined);
+    fs.readFileSync.mockReturnValue('');
+  });
+
+  describe('generate', () => {
+    it('returns results object with expected structure', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: [],
+        oauthProviders: [],
+        isTypeScript: false,
+        routerType: 'app',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result).toHaveProperty('apiClient');
+      expect(result).toHaveProperty('envFile');
+      expect(result).toHaveProperty('nextauth');
+      expect(result).toHaveProperty('oauthGuide');
+      expect(result).toHaveProperty('gitignore');
+    });
+
+    it('generates API client when features are provided', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm'],
+        oauthProviders: [],
+        isTypeScript: false,
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.apiClient).not.toBeNull();
+      expect(result.apiClient).toContain('api-client');
+    });
+
+    it('does not generate API client when no features', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: [],
+        oauthProviders: [],
+        isTypeScript: false,
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.apiClient).toBeNull();
+    });
+
+    it('always generates env file', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: [],
+        oauthProviders: [],
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.envFile).not.toBeNull();
+      expect(result.envFile).toContain('.env.local');
+    });
+
+    it('generates NextAuth config when oauth feature enabled', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: ['google'],
+        isTypeScript: false,
+        routerType: 'app',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.nextauth).not.toBeNull();
+    });
+
+    it('does not generate NextAuth when oauth not in features', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm'],
+        oauthProviders: ['google'],
+        isTypeScript: false,
+        routerType: 'app',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.nextauth).toBeNull();
+    });
+
+    it('does not generate NextAuth when no oauthProviders', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: null,
+        isTypeScript: false,
+        routerType: 'app',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.nextauth).toBeNull();
+    });
+
+    it('generates OAuth guide when oauth feature enabled', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['oauth'],
+        oauthProviders: ['google'],
+        productionDomain: 'example.com',
+        appName: 'Test App',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.oauthGuide).not.toBeNull();
+      expect(result.oauthGuide).toContain('OAUTH_SETUP_GUIDE.md');
+    });
+
+    it('does not generate OAuth guide when oauth not enabled', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm'],
+        oauthProviders: [],
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.oauthGuide).toBeNull();
+    });
+
+    it('always attempts to update gitignore', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: [],
+        oauthProviders: [],
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      // gitignore generator returns path or null depending on if update needed
+      expect(result).toHaveProperty('gitignore');
+    });
+
+    it('generates all files when all features enabled', async () => {
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        features: ['crm', 'oauth', 'stripe'],
+        oauthProviders: ['google', 'github'],
+        isTypeScript: true,
+        routerType: 'app',
+        productionDomain: 'example.com',
+        appName: 'Full App',
+      };
+
+      const result = await FileGenerator.generate(options);
+
+      expect(result.apiClient).not.toBeNull();
+      expect(result.envFile).not.toBeNull();
+      expect(result.nextauth).not.toBeNull();
+      expect(result.oauthGuide).not.toBeNull();
+    });
+  });
+});