@l4yercak3/cli 1.0.6 → 1.1.1

package/tests/backend-client.test.js

@@ -378,4 +378,171 @@ describe('BackendClient', () => {
       expect(result.name).toBe('New Org');
     });
   });
+
+  // ============================================
+  // Connected Applications API Tests
+  // ============================================
+
+  describe('checkExistingApplication', () => {
+    it('returns found=true when application exists', async () => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({
+          found: true,
+          application: {
+            id: 'app-123',
+            name: 'My App',
+          },
+        }),
+      };
+      fetch.mockResolvedValue(mockResponse);
+
+      const result = await BackendClient.checkExistingApplication('org-123', 'hash123');
+
+      expect(fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/api/v1/cli/applications/by-path?organizationId=org-123&hash=hash123'),
+        expect.objectContaining({ method: 'GET' })
+      );
+      expect(result.found).toBe(true);
+      expect(result.application.id).toBe('app-123');
+    });
+
+    it('returns found=false when 404', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 404,
+        json: jest.fn().mockResolvedValue({ error: 'Not found' }),
+      };
+      fetch.mockResolvedValue(mockResponse);
+
+      const result = await BackendClient.checkExistingApplication('org-123', 'hash456');
+
+      expect(result.found).toBe(false);
+    });
+
+    it('throws error on non-404 errors', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 500,
+        json: jest.fn().mockResolvedValue({ message: 'Server error' }),
+      };
+      fetch.mockResolvedValue(mockResponse);
+
+      await expect(BackendClient.checkExistingApplication('org-123', 'hash789'))
+        .rejects.toThrow('Server error');
+    });
+  });
+
+  describe('registerApplication', () => {
+    it('registers new application', async () => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({
+          applicationId: 'app-new-123',
+          backendUrl: 'https://api.l4yercak3.com',
+        }),
+      };
+      fetch.mockResolvedValue(mockResponse);
+
+      const registrationData = {
+        organizationId: 'org-123',
+        name: 'My New App',
+        source: {
+          type: 'cli',
+          projectPathHash: 'hash123',
+          framework: 'nextjs',
+        },
+        connection: {
+          features: ['crm', 'events'],
+        },
+      };
+
+      const result = await BackendClient.registerApplication(registrationData);
+
+      expect(fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/api/v1/cli/applications'),
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify(registrationData),
+        })
+      );
+      expect(result.applicationId).toBe('app-new-123');
+    });
+  });
+
+  describe('updateApplication', () => {
+    it('updates existing application', async () => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({
+          success: true,
+          applicationId: 'app-123',
+        }),
+      };
+      fetch.mockResolvedValue(mockResponse);
+
+      const updates = {
+        connection: {
+          features: ['crm', 'events', 'invoicing'],
+        },
+      };
+
+      const result = await BackendClient.updateApplication('app-123', updates);
+
+      expect(fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/api/v1/cli/applications/app-123'),
+        expect.objectContaining({
+          method: 'PATCH',
+          body: JSON.stringify(updates),
+        })
+      );
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('getApplication', () => {
+    it('fetches application details', async () => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({
+          id: 'app-123',
+          name: 'My App',
+          status: 'active',
+        }),
+      };
+      fetch.mockResolvedValue(mockResponse);
+
+      const result = await BackendClient.getApplication('app-123');
+
+      expect(fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/api/v1/cli/applications/app-123'),
+        expect.objectContaining({ method: 'GET' })
+      );
+      expect(result.id).toBe('app-123');
+      expect(result.status).toBe('active');
+    });
+  });
+
+  describe('listApplications', () => {
+    it('lists applications for organization', async () => {
+      const mockResponse = {
+        ok: true,
+        json: jest.fn().mockResolvedValue({
+          applications: [
+            { id: 'app-1', name: 'App One' },
+            { id: 'app-2', name: 'App Two' },
+          ],
+        }),
+      };
+      fetch.mockResolvedValue(mockResponse);
+
+      const result = await BackendClient.listApplications('org-123');
+
+      expect(fetch).toHaveBeenCalledWith(
+        expect.stringContaining('/api/v1/cli/applications?organizationId=org-123'),
+        expect.objectContaining({ method: 'GET' })
+      );
+      expect(result.applications).toHaveLength(2);
+    });
+  });
 });

package/tests/file-utils.test.js

@@ -0,0 +1,194 @@
+/**
+ * Tests for File Utilities
+ */
+
+const crypto = require('crypto');
+const path = require('path');
+
+jest.mock('fs');
+jest.mock('inquirer');
+
+const fs = require('fs');
+const inquirer = require('inquirer');
+
+// Must require after mocks are set up
+const {
+  GENERATED_HEADER,
+  isGeneratedFile,
+  checkFileOverwrite,
+  writeFileWithBackup,
+  ensureDir,
+  generateProjectPathHash,
+} = require('../src/utils/file-utils');
+
+describe('File Utilities', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.spyOn(console, 'log').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    console.log.mockRestore();
+  });
+
+  describe('generateProjectPathHash', () => {
+    it('generates SHA256 hash of absolute project path', () => {
+      const projectPath = '/test/project/path';
+      const expectedHash = crypto.createHash('sha256')
+        .update(path.resolve(projectPath))
+        .digest('hex');
+
+      const result = generateProjectPathHash(projectPath);
+
+      expect(result).toBe(expectedHash);
+      expect(result).toHaveLength(64); // SHA256 produces 64 hex chars
+    });
+
+    it('generates same hash for same path', () => {
+      const projectPath = '/consistent/path';
+
+      const hash1 = generateProjectPathHash(projectPath);
+      const hash2 = generateProjectPathHash(projectPath);
+
+      expect(hash1).toBe(hash2);
+    });
+
+    it('generates different hashes for different paths', () => {
+      const path1 = '/path/one';
+      const path2 = '/path/two';
+
+      const hash1 = generateProjectPathHash(path1);
+      const hash2 = generateProjectPathHash(path2);
+
+      expect(hash1).not.toBe(hash2);
+    });
+
+    it('handles relative paths by resolving to absolute', () => {
+      const relativePath = './my-project';
+      const absolutePath = path.resolve(relativePath);
+      const expectedHash = crypto.createHash('sha256')
+        .update(absolutePath)
+        .digest('hex');
+
+      const result = generateProjectPathHash(relativePath);
+
+      expect(result).toBe(expectedHash);
+    });
+  });
+
+  describe('isGeneratedFile', () => {
+    it('returns false if file does not exist', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      expect(isGeneratedFile('/nonexistent/file.js')).toBe(false);
+    });
+
+    it('returns true if file contains generated header', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`// ${GENERATED_HEADER}\n// Some content`);
+
+      expect(isGeneratedFile('/test/file.js')).toBe(true);
+    });
+
+    it('returns false if file does not contain generated header', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('// Manual file content\nconst x = 1;');
+
+      expect(isGeneratedFile('/test/file.js')).toBe(false);
+    });
+
+    it('returns false if file read throws error', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockImplementation(() => {
+        throw new Error('Read error');
+      });
+
+      expect(isGeneratedFile('/test/file.js')).toBe(false);
+    });
+  });
+
+  describe('checkFileOverwrite', () => {
+    it('returns write if file does not exist', async () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = await checkFileOverwrite('/new/file.js');
+
+      expect(result).toBe('write');
+    });
+
+    it('returns write if file is generated by us', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`// ${GENERATED_HEADER}\ncontent`);
+
+      const result = await checkFileOverwrite('/test/file.js');
+
+      expect(result).toBe('write');
+    });
+
+    it('returns skip if defaultAction is skip', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('manual content');
+
+      const result = await checkFileOverwrite('/test/file.js', { defaultAction: 'skip' });
+
+      expect(result).toBe('skip');
+    });
+
+    it('prompts user if file exists and is not generated', async () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('manual content');
+      inquirer.prompt.mockResolvedValue({ action: 'backup' });
+
+      const result = await checkFileOverwrite('/test/file.js');
+
+      expect(inquirer.prompt).toHaveBeenCalled();
+      expect(result).toBe('backup');
+    });
+  });
+
+  describe('writeFileWithBackup', () => {
+    it('returns null if action is skip', () => {
+      const result = writeFileWithBackup('/test/file.js', 'content', 'skip');
+
+      expect(result).toBeNull();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('creates backup if action is backup', () => {
+      fs.existsSync.mockReturnValue(true);
+
+      writeFileWithBackup('/test/file.js', 'new content', 'backup');
+
+      expect(fs.copyFileSync).toHaveBeenCalledWith('/test/file.js', '/test/file.js.backup');
+      expect(fs.writeFileSync).toHaveBeenCalledWith('/test/file.js', 'new content', 'utf8');
+    });
+
+    it('writes file directly if action is write', () => {
+      fs.existsSync.mockReturnValue(true);
+
+      const result = writeFileWithBackup('/test/file.js', 'content', 'write');
+
+      expect(fs.copyFileSync).not.toHaveBeenCalled();
+      expect(fs.writeFileSync).toHaveBeenCalledWith('/test/file.js', 'content', 'utf8');
+      expect(result).toBe('/test/file.js');
+    });
+  });
+
+  describe('ensureDir', () => {
+    it('creates directory if it does not exist', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      ensureDir('/test/dir');
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith('/test/dir', { recursive: true });
+    });
+
+    it('does nothing if directory exists', () => {
+      fs.existsSync.mockReturnValue(true);
+
+      ensureDir('/test/dir');
+
+      expect(fs.mkdirSync).not.toHaveBeenCalled();
+    });
+  });
+});

package/tests/generators-index.test.js

@@ -5,6 +5,14 @@
 const fs = require('fs');
 
 jest.mock('fs');
+jest.mock('../src/utils/file-utils', () => ({
+  checkFileOverwrite: jest.fn().mockResolvedValue('write'),
+  writeFileWithBackup: jest.fn((filePath, content, action) => {
+    if (action === 'skip') return null;
+    return filePath;
+  }),
+  ensureDir: jest.fn(),
+}));
 
 const FileGenerator = require('../src/generators/index');
 

package/tests/nextauth-generator.test.js

@@ -6,8 +6,17 @@ const fs = require('fs');
 const path = require('path');
 
 jest.mock('fs');
+jest.mock('../src/utils/file-utils', () => ({
+  checkFileOverwrite: jest.fn().mockResolvedValue('write'),
+  writeFileWithBackup: jest.fn((filePath, content, action) => {
+    if (action === 'skip') return null;
+    return filePath;
+  }),
+  ensureDir: jest.fn(),
+}));
 
 const NextAuthGenerator = require('../src/generators/nextauth-generator');
+const { checkFileOverwrite, writeFileWithBackup, ensureDir } = require('../src/utils/file-utils');
 
 describe('NextAuthGenerator', () => {
   const mockProjectPath = '/test/project';
@@ -17,10 +26,11 @@ describe('NextAuthGenerator', () => {
     fs.existsSync.mockReturnValue(false);
     fs.mkdirSync.mockReturnValue(undefined);
     fs.writeFileSync.mockReturnValue(undefined);
+    checkFileOverwrite.mockResolvedValue('write');
   });
 
   describe('generate', () => {
-    it('creates route.js in app/api/auth/[...nextauth] for App Router', () => {
+    it('creates route.js in app/api/auth/[...nextauth] for App Router', async () => {
       const options = {
         projectPath: mockProjectPath,
         backendUrl: 'https://backend.test.com',
@@ -29,22 +39,20 @@ describe('NextAuthGenerator', () => {
         isTypeScript: false,
       };
 
-      const result = NextAuthGenerator.generate(options);
+      const result = await NextAuthGenerator.generate(options);
 
       expect(result).toBe(
         path.join(mockProjectPath, 'app', 'api', 'auth', '[...nextauth]', 'route.js')
       );
-      expect(fs.mkdirSync).toHaveBeenCalledWith(
-        path.join(mockProjectPath, 'app', 'api', 'auth'),
-        { recursive: true }
+      expect(ensureDir).toHaveBeenCalledWith(
+        path.join(mockProjectPath, 'app', 'api', 'auth')
       );
-      expect(fs.mkdirSync).toHaveBeenCalledWith(
-        path.join(mockProjectPath, 'app', 'api', 'auth', '[...nextauth]'),
-        { recursive: true }
+      expect(ensureDir).toHaveBeenCalledWith(
+        path.join(mockProjectPath, 'app', 'api', 'auth', '[...nextauth]')
       );
     });
 
-    it('creates [...nextauth].ts in pages/api/auth for Pages Router', () => {
+    it('creates [...nextauth].ts in pages/api/auth for Pages Router', async () => {
       const options = {
         projectPath: mockProjectPath,
         backendUrl: 'https://backend.test.com',
@@ -53,14 +61,30 @@ describe('NextAuthGenerator', () => {
         isTypeScript: true,
       };
 
-      const result = NextAuthGenerator.generate(options);
+      const result = await NextAuthGenerator.generate(options);
 
       expect(result).toBe(
         path.join(mockProjectPath, 'pages', 'api', 'auth', '[...nextauth].ts')
       );
     });
 
-    it('does not create [...nextauth] dir for Pages Router', () => {
+    it('returns null when user skips overwrite', async () => {
+      checkFileOverwrite.mockResolvedValue('skip');
+
+      const options = {
+        projectPath: mockProjectPath,
+        backendUrl: 'https://backend.test.com',
+        oauthProviders: ['google'],
+        routerType: 'app',
+        isTypeScript: false,
+      };
+
+      const result = await NextAuthGenerator.generate(options);
+
+      expect(result).toBeNull();
+    });
+
+    it('does not create [...nextauth] dir for Pages Router', async () => {
       const options = {
         projectPath: mockProjectPath,
         backendUrl: 'https://backend.test.com',
@@ -69,11 +93,11 @@ describe('NextAuthGenerator', () => {
         isTypeScript: false,
       };
 
-      NextAuthGenerator.generate(options);
+      await NextAuthGenerator.generate(options);
 
       // Should only create pages/api/auth, not [...nextauth] dir
-      const mkdirCalls = fs.mkdirSync.mock.calls.map((c) => c[0]);
-      expect(mkdirCalls).not.toContain(
+      const ensureDirCalls = ensureDir.mock.calls.map((c) => c[0]);
+      expect(ensureDirCalls).not.toContain(
         path.join(mockProjectPath, 'pages', 'api', 'auth', '[...nextauth]')
       );
     });