@l4yercak3/cli 1.0.0

package/tests/api-client-detector.test.js

@@ -0,0 +1,214 @@
+/**
+ * Tests for API Client Detector
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const ApiClientDetector = require('../src/detectors/api-client-detector');
+
+describe('ApiClientDetector', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+  });
+
+  describe('detect', () => {
+    it('returns hasApiClient false when no API client exists', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = ApiClientDetector.detect(mockProjectPath);
+
+      expect(result.hasApiClient).toBe(false);
+      expect(result.clientPath).toBeNull();
+      expect(result.clientType).toBeNull();
+    });
+
+    describe('API client path detection', () => {
+      const testPaths = [
+        'lib/api-client.ts',
+        'lib/api-client.js',
+        'lib/api.ts',
+        'lib/api.js',
+        'src/lib/api-client.ts',
+        'src/lib/api-client.js',
+        'utils/api-client.ts',
+        'utils/api.js',
+        'src/utils/api-client.ts',
+      ];
+
+      testPaths.forEach((clientPath) => {
+        it(`detects API client at ${clientPath}`, () => {
+          fs.existsSync.mockImplementation((p) =>
+            p === path.join(mockProjectPath, clientPath)
+          );
+          fs.readFileSync.mockReturnValue('fetch()');
+
+          const result = ApiClientDetector.detect(mockProjectPath);
+
+          expect(result.hasApiClient).toBe(true);
+          expect(result.clientPath).toBe(clientPath);
+        });
+      });
+    });
+
+    describe('client type detection', () => {
+      it('detects axios client', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'lib/api-client.ts')
+        );
+        fs.readFileSync.mockReturnValue(`
+          import axios from 'axios';
+          export const api = axios.create({});
+        `);
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.clientType).toBe('axios');
+      });
+
+      it('detects fetch client', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'lib/api-client.ts')
+        );
+        fs.readFileSync.mockReturnValue(`
+          export async function request(url) {
+            return fetch(url);
+          }
+        `);
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.clientType).toBe('fetch');
+      });
+
+      it('detects custom client (no axios or fetch)', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'lib/api-client.ts')
+        );
+        fs.readFileSync.mockReturnValue(`
+          import { request } from 'custom-http';
+          export const api = request;
+        `);
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.clientType).toBe('custom');
+      });
+
+      it('prefers axios over fetch when both present', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'lib/api-client.ts')
+        );
+        fs.readFileSync.mockReturnValue(`
+          import axios from 'axios';
+          // also uses fetch as fallback
+          const fallback = fetch;
+        `);
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.clientType).toBe('axios');
+      });
+
+      it('returns unknown on read error', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, 'lib/api-client.ts')
+        );
+        fs.readFileSync.mockImplementation(() => {
+          throw new Error('Read failed');
+        });
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.hasApiClient).toBe(true);
+        expect(result.clientType).toBe('unknown');
+      });
+    });
+
+    describe('environment file detection', () => {
+      it('detects .env.local', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, '.env.local')
+        );
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.hasEnvFile).toBe(true);
+        expect(result.envFilePath).toBe('.env.local');
+      });
+
+      it('detects .env', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, '.env')
+        );
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.hasEnvFile).toBe(true);
+        expect(result.envFilePath).toBe('.env');
+      });
+
+      it('detects .env.development', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, '.env.development')
+        );
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.hasEnvFile).toBe(true);
+        expect(result.envFilePath).toBe('.env.development');
+      });
+
+      it('detects .env.production', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, '.env.production')
+        );
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.hasEnvFile).toBe(true);
+        expect(result.envFilePath).toBe('.env.production');
+      });
+
+      it('prefers .env.local over other env files', () => {
+        fs.existsSync.mockImplementation((p) =>
+          p === path.join(mockProjectPath, '.env.local') ||
+          p === path.join(mockProjectPath, '.env')
+        );
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.envFilePath).toBe('.env.local');
+      });
+
+      it('returns hasEnvFile false when no env file exists', () => {
+        fs.existsSync.mockReturnValue(false);
+
+        const result = ApiClientDetector.detect(mockProjectPath);
+
+        expect(result.hasEnvFile).toBe(false);
+        expect(result.envFilePath).toBeNull();
+      });
+    });
+
+    it('stops at first found API client', () => {
+      let callCount = 0;
+      fs.existsSync.mockImplementation((p) => {
+        callCount++;
+        return p === path.join(mockProjectPath, 'lib/api-client.ts');
+      });
+      fs.readFileSync.mockReturnValue('fetch');
+
+      ApiClientDetector.detect(mockProjectPath);
+
+      // Should stop checking after finding first client
+      // (only checks up to lib/api-client.ts which is index 0)
+      expect(callCount).toBeLessThan(20);
+    });
+  });
+});

package/tests/api-client-generator.test.js

@@ -0,0 +1,169 @@
+/**
+ * Tests for API Client Generator
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const ApiClientGenerator = require('../src/generators/api-client-generator');
+
+describe('ApiClientGenerator', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+    fs.mkdirSync.mockReturnValue(undefined);
+    fs.writeFileSync.mockReturnValue(undefined);
+  });
+
+  describe('generate', () => {
+    it('creates api-client.js in lib folder when no src exists', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        isTypeScript: false,
+      };
+
+      const result = ApiClientGenerator.generate(options);
+
+      expect(result).toBe(path.join(mockProjectPath, 'lib', 'api-client.js'));
+      expect(fs.mkdirSync).toHaveBeenCalledWith(
+        path.join(mockProjectPath, 'lib'),
+        { recursive: true }
+      );
+      expect(fs.writeFileSync).toHaveBeenCalled();
+    });
+
+    it('creates api-client.ts in src/lib folder when src exists', () => {
+      fs.existsSync.mockImplementation((p) =>
+        p === path.join(mockProjectPath, 'src')
+      );
+
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        isTypeScript: true,
+      };
+
+      const result = ApiClientGenerator.generate(options);
+
+      expect(result).toBe(path.join(mockProjectPath, 'src', 'lib', 'api-client.ts'));
+    });
+
+    it('does not create lib dir if it exists', () => {
+      fs.existsSync.mockReturnValue(true);
+
+      const options = {
+        projectPath: mockProjectPath,
+        apiKey: 'test-api-key',
+        backendUrl: 'https://backend.test.com',
+        organizationId: 'org-123',
+        isTypeScript: false,
+      };
+
+      ApiClientGenerator.generate(options);
+
+      expect(fs.mkdirSync).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('generateCode', () => {
+    it('generates JavaScript code without type annotations', () => {
+      const code = ApiClientGenerator.generateCode({
+        apiKey: 'my-api-key',
+        backendUrl: 'https://api.example.com',
+        organizationId: 'org-456',
+        isTypeScript: false,
+      });
+
+      expect(code).toContain('L4YERCAK3 API Client');
+      expect(code).toContain("apiKey = 'my-api-key'");
+      expect(code).toContain("baseUrl = 'https://api.example.com'");
+      expect(code).toContain("this.organizationId = 'org-456'");
+      expect(code).toContain('module.exports = L4YERCAK3Client;');
+      expect(code).not.toContain(': string');
+      expect(code).not.toContain(': Promise<any>');
+    });
+
+    it('generates TypeScript code with type annotations', () => {
+      const code = ApiClientGenerator.generateCode({
+        apiKey: 'my-api-key',
+        backendUrl: 'https://api.example.com',
+        organizationId: 'org-456',
+        isTypeScript: true,
+      });
+
+      expect(code).toContain(': string');
+      expect(code).toContain(': Promise<any>');
+      expect(code).toContain(': RequestInit');
+      expect(code).toContain('export default L4YERCAK3Client;');
+    });
+
+    it('includes CRM methods', () => {
+      const code = ApiClientGenerator.generateCode({
+        apiKey: 'key',
+        backendUrl: 'url',
+        organizationId: 'org',
+        isTypeScript: false,
+      });
+
+      expect(code).toContain('getContacts()');
+      expect(code).toContain('getContact(contactId');
+      expect(code).toContain('createContact(data');
+      expect(code).toContain('updateContact(contactId');
+      expect(code).toContain('deleteContact(contactId');
+    });
+
+    it('includes Projects methods', () => {
+      const code = ApiClientGenerator.generateCode({
+        apiKey: 'key',
+        backendUrl: 'url',
+        organizationId: 'org',
+        isTypeScript: false,
+      });
+
+      expect(code).toContain('getProjects()');
+      expect(code).toContain('getProject(projectId');
+      expect(code).toContain('createProject(data');
+      expect(code).toContain('updateProject(projectId');
+      expect(code).toContain('deleteProject(projectId');
+    });
+
+    it('includes Invoices methods', () => {
+      const code = ApiClientGenerator.generateCode({
+        apiKey: 'key',
+        backendUrl: 'url',
+        organizationId: 'org',
+        isTypeScript: false,
+      });
+
+      expect(code).toContain('getInvoices()');
+      expect(code).toContain('getInvoice(invoiceId');
+      expect(code).toContain('createInvoice(data');
+      expect(code).toContain('updateInvoice(invoiceId');
+      expect(code).toContain('deleteInvoice(invoiceId');
+    });
+
+    it('includes request method with proper headers', () => {
+      const code = ApiClientGenerator.generateCode({
+        apiKey: 'key',
+        backendUrl: 'url',
+        organizationId: 'org',
+        isTypeScript: false,
+      });
+
+      expect(code).toContain("'Content-Type': 'application/json'");
+      expect(code).toContain('Authorization');
+      expect(code).toContain('X-Organization-Id');
+    });
+  });
+});