@l4yercak3/cli 1.0.0

package/tests/github-detector.test.js

@@ -0,0 +1,145 @@
+/**
+ * Tests for GitHub Detector
+ */
+
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+jest.mock('fs');
+jest.mock('child_process');
+
+const GitHubDetector = require('../src/detectors/github-detector');
+
+describe('GitHubDetector', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('detect', () => {
+    it('returns hasGit false when no .git directory exists', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.hasGit).toBe(false);
+      expect(result.isGitHub).toBe(false);
+      expect(result.owner).toBeNull();
+      expect(result.repo).toBeNull();
+    });
+
+    it('returns hasGit true when .git directory exists', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync.mockReturnValue('https://github.com/owner/repo.git\n');
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.hasGit).toBe(true);
+    });
+
+    it('parses HTTPS GitHub URL correctly', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync
+        .mockReturnValueOnce('https://github.com/myorg/myrepo.git\n')
+        .mockReturnValueOnce('main\n');
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.isGitHub).toBe(true);
+      expect(result.owner).toBe('myorg');
+      expect(result.repo).toBe('myrepo');
+      expect(result.url).toBe('https://github.com/myorg/myrepo');
+      expect(result.branch).toBe('main');
+    });
+
+    it('parses SSH GitHub URL correctly', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync
+        .mockReturnValueOnce('git@github.com:myorg/myrepo.git\n')
+        .mockReturnValueOnce('develop\n');
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.isGitHub).toBe(true);
+      expect(result.owner).toBe('myorg');
+      expect(result.repo).toBe('myrepo');
+      expect(result.url).toBe('https://github.com/myorg/myrepo');
+      expect(result.branch).toBe('develop');
+    });
+
+    it('parses GitHub URL without .git extension', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync
+        .mockReturnValueOnce('https://github.com/owner/repo\n')
+        .mockReturnValueOnce('main\n');
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.isGitHub).toBe(true);
+      expect(result.owner).toBe('owner');
+      expect(result.repo).toBe('repo');
+    });
+
+    it('returns isGitHub false for non-GitHub remote', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync.mockReturnValue('https://gitlab.com/owner/repo.git\n');
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.hasGit).toBe(true);
+      expect(result.isGitHub).toBe(false);
+      expect(result.owner).toBeNull();
+      expect(result.repo).toBeNull();
+    });
+
+    it('handles empty remote URL', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync.mockReturnValue('\n');
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.hasGit).toBe(true);
+      expect(result.isGitHub).toBe(false);
+    });
+
+    it('handles git command failure gracefully', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync.mockImplementation(() => {
+        throw new Error('git command failed');
+      });
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.hasGit).toBe(true);
+      expect(result.isGitHub).toBe(false);
+    });
+
+    it('handles branch detection failure gracefully', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync
+        .mockReturnValueOnce('https://github.com/owner/repo.git\n')
+        .mockImplementationOnce(() => {
+          throw new Error('branch command failed');
+        });
+
+      const result = GitHubDetector.detect(mockProjectPath);
+
+      expect(result.isGitHub).toBe(true);
+      expect(result.owner).toBe('owner');
+      expect(result.branch).toBeNull();
+    });
+
+    it('uses correct working directory for git commands', () => {
+      fs.existsSync.mockReturnValue(true);
+      execSync.mockReturnValue('https://github.com/owner/repo.git\n');
+
+      GitHubDetector.detect(mockProjectPath);
+
+      expect(execSync).toHaveBeenCalledWith(
+        'git config --get remote.origin.url',
+        expect.objectContaining({ cwd: mockProjectPath })
+      );
+    });
+  });
+});

package/tests/gitignore-generator.test.js

@@ -0,0 +1,109 @@
+/**
+ * Tests for Gitignore Generator
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const GitignoreGenerator = require('../src/generators/gitignore-generator');
+
+describe('GitignoreGenerator', () => {
+  const mockProjectPath = '/test/project';
+  const mockGitignorePath = path.join(mockProjectPath, '.gitignore');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+    fs.writeFileSync.mockReturnValue(undefined);
+  });
+
+  describe('generate', () => {
+    it('creates new .gitignore with L4YERCAK3 entries', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      const result = GitignoreGenerator.generate({ projectPath: mockProjectPath });
+
+      expect(result).toBe(mockGitignorePath);
+      expect(fs.writeFileSync).toHaveBeenCalled();
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('# L4YERCAK3 Configuration');
+      expect(writtenContent).toContain('.env.local');
+      expect(writtenContent).toContain('.env*.local');
+      expect(writtenContent).toContain('.l4yercak3/');
+    });
+
+    it('appends to existing .gitignore', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`# Existing gitignore
+node_modules/
+.DS_Store
+`);
+
+      const result = GitignoreGenerator.generate({ projectPath: mockProjectPath });
+
+      expect(result).toBe(mockGitignorePath);
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('node_modules/');
+      expect(writtenContent).toContain('.DS_Store');
+      expect(writtenContent).toContain('# L4YERCAK3 Configuration');
+      expect(writtenContent).toContain('.env.local');
+    });
+
+    it('returns null when all entries already exist', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`# L4YERCAK3 Configuration
+# Auto-generated by @l4yercak3/cli
+.env.local
+.env*.local
+.l4yercak3/
+`);
+
+      const result = GitignoreGenerator.generate({ projectPath: mockProjectPath });
+
+      expect(result).toBeNull();
+      expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('adds missing entries when some already exist', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`# L4YERCAK3 Configuration
+.env.local
+`);
+
+      GitignoreGenerator.generate({ projectPath: mockProjectPath });
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      expect(writtenContent).toContain('.env*.local');
+      expect(writtenContent).toContain('.l4yercak3/');
+    });
+
+    it('adds newline before section if file does not end with newline', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('node_modules/');
+
+      GitignoreGenerator.generate({ projectPath: mockProjectPath });
+
+      const writtenContent = fs.writeFileSync.mock.calls[0][1];
+      // Should have newline between existing content and new section
+      expect(writtenContent).toMatch(/node_modules\/\n\n# L4YERCAK3 Configuration/);
+    });
+
+    it('handles whitespace variations in existing entries', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(`# Some config
+  .env.local
+.env*.local
+  .l4yercak3/
+# L4YERCAK3 Configuration
+`);
+
+      const result = GitignoreGenerator.generate({ projectPath: mockProjectPath });
+
+      expect(result).toBeNull();
+    });
+  });
+});

package/tests/logo.test.js

@@ -0,0 +1,96 @@
+/**
+ * Tests for Logo Module
+ */
+
+const figlet = require('figlet');
+
+jest.mock('chalk', () => {
+  const mockChalk = (text) => text;
+  mockChalk.hex = () => mockChalk;
+  return mockChalk;
+});
+
+jest.mock('figlet', () => ({
+  textSync: jest.fn().mockReturnValue('MOCK LOGO\nLINE 2\nLINE 3'),
+}));
+
+// Spy on console.log
+const originalConsoleLog = console.log;
+let consoleOutput = [];
+
+beforeEach(() => {
+  consoleOutput = [];
+  console.log = jest.fn((...args) => {
+    consoleOutput.push(args.join(' '));
+  });
+});
+
+afterEach(() => {
+  console.log = originalConsoleLog;
+});
+
+const { showLogo, rainbow } = require('../src/logo');
+
+describe('Logo Module', () => {
+  describe('rainbow export', () => {
+    it('exports rainbow color array', () => {
+      expect(Array.isArray(rainbow)).toBe(true);
+      expect(rainbow.length).toBeGreaterThan(0);
+    });
+
+    it('contains valid hex colors', () => {
+      rainbow.forEach((color) => {
+        expect(color).toMatch(/^#[0-9A-Fa-f]{6}$/);
+      });
+    });
+  });
+
+  describe('showLogo', () => {
+    it('calls figlet.textSync with L4YERCAK3', () => {
+      showLogo(false);
+
+      expect(figlet.textSync).toHaveBeenCalledWith(
+        'L4YERCAK3',
+        expect.objectContaining({
+          font: '3D-ASCII',
+        })
+      );
+    });
+
+    it('prints logo lines to console', () => {
+      showLogo(false);
+
+      // Should have printed the mocked logo lines
+      expect(consoleOutput.some((line) => line.includes('MOCK LOGO'))).toBe(true);
+    });
+
+    it('shows building metaphor by default', () => {
+      showLogo();
+
+      // Should print building metaphor lines
+      const output = consoleOutput.join('\n');
+      expect(output.length).toBeGreaterThan(100);
+    });
+
+    it('hides building metaphor when showBuilding is false', () => {
+      showLogo(false);
+
+      // Output should be shorter without building
+      const outputWithoutBuilding = consoleOutput.length;
+
+      consoleOutput = [];
+      showLogo(true);
+
+      const outputWithBuilding = consoleOutput.length;
+
+      expect(outputWithBuilding).toBeGreaterThan(outputWithoutBuilding);
+    });
+
+    it('prints spacing after logo', () => {
+      showLogo(false);
+
+      // Last output should be empty (spacing)
+      expect(consoleOutput[consoleOutput.length - 1]).toBe('');
+    });
+  });
+});

package/tests/nextauth-generator.test.js

@@ -0,0 +1,231 @@
+/**
+ * Tests for NextAuth Generator
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+jest.mock('fs');
+
+const NextAuthGenerator = require('../src/generators/nextauth-generator');
+
+describe('NextAuthGenerator', () => {
+  const mockProjectPath = '/test/project';
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fs.existsSync.mockReturnValue(false);
+    fs.mkdirSync.mockReturnValue(undefined);
+    fs.writeFileSync.mockReturnValue(undefined);
+  });
+
+  describe('generate', () => {
+    it('creates route.js in app/api/auth/[...nextauth] for App Router', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        backendUrl: 'https://backend.test.com',
+        oauthProviders: ['google'],
+        routerType: 'app',
+        isTypeScript: false,
+      };
+
+      const result = 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(fs.mkdirSync).toHaveBeenCalledWith(
+        path.join(mockProjectPath, 'app', 'api', 'auth', '[...nextauth]'),
+        { recursive: true }
+      );
+    });
+
+    it('creates [...nextauth].ts in pages/api/auth for Pages Router', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        backendUrl: 'https://backend.test.com',
+        oauthProviders: ['google'],
+        routerType: 'pages',
+        isTypeScript: true,
+      };
+
+      const result = NextAuthGenerator.generate(options);
+
+      expect(result).toBe(
+        path.join(mockProjectPath, 'pages', 'api', 'auth', '[...nextauth].ts')
+      );
+    });
+
+    it('does not create [...nextauth] dir for Pages Router', () => {
+      const options = {
+        projectPath: mockProjectPath,
+        backendUrl: 'https://backend.test.com',
+        oauthProviders: ['google'],
+        routerType: 'pages',
+        isTypeScript: false,
+      };
+
+      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(
+        path.join(mockProjectPath, 'pages', 'api', 'auth', '[...nextauth]')
+      );
+    });
+  });
+
+  describe('generateCode', () => {
+    describe('Google provider', () => {
+      it('includes Google provider import and config', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['google'],
+          routerType: 'app',
+          isTypeScript: false,
+        });
+
+        expect(code).toContain("import GoogleProvider from 'next-auth/providers/google'");
+        expect(code).toContain('GoogleProvider({');
+        expect(code).toContain('process.env.GOOGLE_CLIENT_ID');
+        expect(code).toContain('process.env.GOOGLE_CLIENT_SECRET');
+      });
+    });
+
+    describe('Microsoft provider', () => {
+      it('includes Azure AD provider import and config', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['microsoft'],
+          routerType: 'app',
+          isTypeScript: false,
+        });
+
+        expect(code).toContain("import AzureADProvider from 'next-auth/providers/azure-ad'");
+        expect(code).toContain('AzureADProvider({');
+        expect(code).toContain('process.env.AZURE_CLIENT_ID');
+        expect(code).toContain('process.env.AZURE_CLIENT_SECRET');
+        expect(code).toContain('process.env.AZURE_TENANT_ID');
+      });
+    });
+
+    describe('GitHub provider', () => {
+      it('includes GitHub provider import and config', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['github'],
+          routerType: 'app',
+          isTypeScript: false,
+        });
+
+        expect(code).toContain("import GitHubProvider from 'next-auth/providers/github'");
+        expect(code).toContain('GitHubProvider({');
+        expect(code).toContain('process.env.GITHUB_CLIENT_ID');
+        expect(code).toContain('process.env.GITHUB_CLIENT_SECRET');
+      });
+    });
+
+    describe('multiple providers', () => {
+      it('includes all selected providers', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['google', 'microsoft', 'github'],
+          routerType: 'app',
+          isTypeScript: false,
+        });
+
+        expect(code).toContain('GoogleProvider');
+        expect(code).toContain('AzureADProvider');
+        expect(code).toContain('GitHubProvider');
+      });
+    });
+
+    describe('App Router format', () => {
+      it('uses route handler exports', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['google'],
+          routerType: 'app',
+          isTypeScript: false,
+        });
+
+        expect(code).toContain('export { handler as GET, handler as POST }');
+        expect(code).toContain('const handler = NextAuth(authOptions)');
+        expect(code).toContain("import type { NextAuthOptions } from 'next-auth'");
+      });
+    });
+
+    describe('Pages Router format', () => {
+      it('uses default export', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['google'],
+          routerType: 'pages',
+          isTypeScript: false,
+        });
+
+        expect(code).toContain('export default NextAuth({');
+        expect(code).not.toContain('export { handler as GET');
+      });
+    });
+
+    describe('TypeScript support', () => {
+      it('adds non-null assertions for TypeScript', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['google'],
+          routerType: 'app',
+          isTypeScript: true,
+        });
+
+        expect(code).toContain('process.env.GOOGLE_CLIENT_ID!');
+        expect(code).toContain('process.env.GOOGLE_CLIENT_SECRET!');
+      });
+
+      it('omits non-null assertions for JavaScript', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['google'],
+          routerType: 'app',
+          isTypeScript: false,
+        });
+
+        expect(code).not.toContain('GOOGLE_CLIENT_ID!');
+        expect(code).not.toContain('GOOGLE_CLIENT_SECRET!');
+      });
+    });
+
+    describe('callbacks', () => {
+      it('includes signIn callback with backend sync', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['google'],
+          routerType: 'app',
+          isTypeScript: false,
+        });
+
+        expect(code).toContain('async signIn({ user, account, profile })');
+        expect(code).toContain('/api/v1/auth/sync-user');
+        expect(code).toContain('NEXT_PUBLIC_L4YERCAK3_BACKEND_URL');
+        expect(code).toContain('L4YERCAK3_API_KEY');
+      });
+
+      it('includes session callback', () => {
+        const code = NextAuthGenerator.generateCode({
+          oauthProviders: ['google'],
+          routerType: 'app',
+          isTypeScript: false,
+        });
+
+        expect(code).toContain('async session({ session, user');
+        expect(code).toContain('session.user.id');
+        expect(code).toContain('session.user.organizationId');
+      });
+    });
+
+    it('includes custom signin page', () => {
+      const code = NextAuthGenerator.generateCode({
+        oauthProviders: ['google'],
+        routerType: 'app',
+        isTypeScript: false,
+      });
+
+      expect(code).toContain("signIn: '/auth/signin'");
+    });
+  });
+});