refactor jenkins client

src/api/ci/gitlabciClient.ts

@@ -146,23 +146,24 @@ export class GitLabCIClient {
    * @param jobId The job ID for which to retrieve logs
    * @returns A promise that resolves to the job logs as a string
    */
-  // public async getPipelineLogs(projectPath: string, jobId: number): Promise<string> {
-  //   try {
-  //     // Access the raw REST API client to make a direct request for job logs
-  //     const gitlab = this.gitlabClient.getClient();
+  //TODO: need to confirm if this is correct
+  public async getPipelineLogs(projectPath: string, jobId: number): Promise<string> {
+    try {
+      // Access the raw REST API client to make a direct request for job logs
+      const gitlab = this.gitlabClient.getClient();
 
-  //     // GitLab API endpoint for job traces is GET /projects/:id/jobs/:job_id/trace
-  //     const encodedProjectPath = encodeURIComponent(projectPath);
-  //     const url = `projects/${encodedProjectPath}/jobs/${jobId}/trace`;
+      // GitLab API endpoint for job traces is GET /projects/:id/jobs/:job_id/trace
+      const encodedProjectPath = encodeURIComponent(projectPath);
+      const url = `projects/${encodedProjectPath}/jobs/${jobId}/trace`;
 
-  //     // Make the request using the underlying requester
-  //     const jobTrace = await gitlab.request.get(url);
-  //     return jobTrace as string;
-  //   } catch (error) {
-  //     console.error(`Failed to get logs for job ${jobId} in project ${projectPath}:`, error);
-  //     return 'Failed to retrieve job logs';
-  //   }
-  // }
+      // Make the request using the underlying requester
+      const jobTrace = await gitlab.requester.get(url);
+      return jobTrace as unknown as string;
+    } catch (error) {
+      console.error(`Failed to get logs for job ${jobId} in project ${projectPath}:`, error);
+      return 'Failed to retrieve job logs';
+    }
+  }
 
   /**
    * Maps GitLab pipeline status to our standardized PipelineStatus enum

src/api/ci/jenkins/README.md

@@ -0,0 +1,231 @@
+# Jenkins Client - Refactored Architecture
+
+This directory contains the refactored Jenkins client implementation following TypeScript best practices and design patterns.
+
+## Architecture Overview
+
+The Jenkins client has been refactored using a service-oriented architecture with the following benefits:
+
+- **Single Responsibility Principle**: Each class has one clear purpose
+- **Type Safety**: Comprehensive TypeScript types throughout
+- **Testability**: Smaller, focused classes are easier to unit test
+- **Maintainability**: Changes to specific functionality affect fewer files
+- **Reusability**: Utility classes can be reused across the codebase
+- **Error Handling**: Consistent, typed error handling
+- **Configuration**: Centralized configuration management
+- **Extensibility**: Easy to add new credential types or job configurations
+
+## Directory Structure
+
+```
+jenkins/
+├── enums/                    # Enums for Jenkins constants
+│   └── jenkins.enums.ts
+├── types/                    # TypeScript type definitions
+│   └── jenkins.types.ts
+├── config/                   # Configuration constants
+│   └── jenkins.config.ts
+├── errors/                   # Custom error classes
+│   └── jenkins.errors.ts
+├── utils/                    # Utility classes
+│   └── jenkins.utils.ts
+├── strategies/               # Strategy pattern implementations
+│   └── credential.strategy.ts
+├── http/                     # HTTP client abstraction
+│   └── jenkins-http.client.ts
+├── services/                 # Business logic services
+│   ├── jenkins-job.service.ts
+│   ├── jenkins-build.service.ts
+│   └── jenkins-credential.service.ts
+├── jenkins.client.ts         # Main client facade
+├── index.ts                  # Module exports
+└── README.md                 # This file
+```
+
+## Usage Examples
+
+### Basic Usage (Backwards Compatible)
+
+```typescript
+import { JenkinsClient } from './jenkins';
+
+const client = new JenkinsClient({
+  baseUrl: 'https://jenkins.example.com',
+  username: 'your-username',
+  token: 'your-api-token'
+});
+
+// Create a job (legacy method signature)
+await client.createJob(
+  'my-job',
+  'https://github.com/user/repo.git',
+  'my-folder',
+  'main',
+  'Jenkinsfile',
+  'git-credentials'
+);
+
+// Trigger a build
+await client.build('my-job', 'my-folder', { PARAM1: 'value1' });
+
+// Get build information
+const build = await client.getBuild('my-job', 123, 'my-folder');
+```
+
+### New Options-Based Usage
+
+```typescript
+import { JenkinsClient, CreateJobOptions, BuildOptions } from './jenkins';
+
+const client = new JenkinsClient({
+  baseUrl: 'https://jenkins.example.com',
+  username: 'your-username',
+  token: 'your-api-token'
+});
+
+// Create a job (new options signature)
+const jobOptions: CreateJobOptions = {
+  jobName: 'my-job',
+  repoUrl: 'https://github.com/user/repo.git',
+  folderName: 'my-folder',
+  branch: 'main',
+  jenkinsfilePath: 'Jenkinsfile',
+  credentialId: 'git-credentials'
+};
+await client.createJob(jobOptions);
+
+// Trigger a build with options
+const buildOptions: BuildOptions = {
+  jobName: 'my-job',
+  folderName: 'my-folder',
+  parameters: { PARAM1: 'value1' }
+};
+await client.build(buildOptions);
+```
+
+### Direct Service Access
+
+```typescript
+import { JenkinsClient } from './jenkins';
+
+const client = new JenkinsClient(config);
+
+// Access individual services for advanced operations
+const jobs = client.jobs;
+const builds = client.builds;
+const credentials = client.credentials;
+
+// Use services directly
+const runningBuilds = await builds.getRunningBuilds('my-job', 'my-folder');
+const jobExists = await jobs.jobExists('my-job', 'my-folder');
+await credentials.createSecretTextCredential('my-folder', 'my-secret', 'secret-value');
+```
+
+### Error Handling
+
+```typescript
+import { 
+  JenkinsClient, 
+  JenkinsJobNotFoundError, 
+  JenkinsBuildTimeoutError,
+  JenkinsAuthenticationError 
+} from './jenkins';
+
+try {
+  const build = await client.getBuild('non-existent-job', 123);
+} catch (error) {
+  if (error instanceof JenkinsJobNotFoundError) {
+    console.log('Job not found:', error.message);
+  } else if (error instanceof JenkinsAuthenticationError) {
+    console.log('Authentication failed:', error.message);
+  } else {
+    console.log('Unexpected error:', error);
+  }
+}
+```
+
+## Design Patterns Used
+
+### 1. Facade Pattern
+- `JenkinsClient` acts as a facade providing a simple interface to the complex subsystem
+
+### 2. Strategy Pattern
+- `CredentialStrategy` and implementations for different credential types
+- Easy to add new credential types without modifying existing code
+
+### 3. Service Layer Pattern
+- Business logic separated into focused service classes
+- Each service handles one domain (jobs, builds, credentials)
+
+### 4. Builder Pattern
+- `JenkinsXmlBuilder` for constructing XML configurations
+- `JenkinsPathBuilder` for constructing API paths
+
+### 5. Factory Pattern
+- `CredentialStrategyFactory` for creating credential strategies
+
+### 6. Error Handling Pattern
+- Custom error hierarchy with specific error types
+- Consistent error handling across all services
+
+## Configuration
+
+All configuration constants are centralized in `JenkinsConfig`:
+
+```typescript
+import { JenkinsConfig } from './jenkins';
+
+// Access default values
+const timeout = JenkinsConfig.DEFAULT_TIMEOUT_MS;
+const headers = JenkinsConfig.HEADERS.JSON;
+const endpoint = JenkinsConfig.ENDPOINTS.API_JSON;
+```
+
+## Extending the Client
+
+### Adding New Credential Types
+
+1. Add the new type to `CredentialType` enum
+2. Create a new strategy class implementing `CredentialStrategy`
+3. Register it in `CredentialStrategyFactory`
+
+### Adding New Services
+
+1. Create a new service class in `services/`
+2. Add it to the main `JenkinsClient` constructor
+3. Expose it through the facade if needed
+
+### Adding New Error Types
+
+1. Create new error classes extending `JenkinsError`
+2. Export them from `errors/jenkins.errors.ts`
+3. Use them in appropriate services
+
+## Testing
+
+The refactored architecture makes testing much easier:
+
+```typescript
+// Mock individual services
+const mockJobService = {
+  createJob: jest.fn(),
+  getJob: jest.fn(),
+};
+
+// Test services in isolation
+const jobService = new JenkinsJobService(mockHttpClient);
+```
+
+## Performance Considerations
+
+- Services are lightweight and share the same HTTP client instance
+- Path building and XML generation are optimized
+- Error handling is consistent and efficient
+- Configuration is loaded once and reused
+
+## Security
+
+- Credentials are handled through the strategy pattern
+- Sensitive data is not logged
+- XML escaping prevents injection attacks
+- Type-safe parameter handling 

src/api/ci/jenkins/config/jenkins.config.ts

@@ -0,0 +1,44 @@
+/**
+ * Jenkins configuration constants and default values
+ */
+export class JenkinsConfig {
+  public static readonly DEFAULT_BRANCH = 'main';
+  public static readonly DEFAULT_JENKINSFILE_PATH = 'Jenkinsfile';
+  public static readonly DEFAULT_CREDENTIAL_ID = 'GITOPS_AUTH_PASSWORD';
+  public static readonly DEFAULT_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
+  public static readonly DEFAULT_POLL_INTERVAL_MS = 5000; // 5 seconds
+  public static readonly DEFAULT_MAX_BUILDS_TO_CHECK = 50;
+
+  /**
+   * HTTP headers for different content types
+   */
+  public static readonly HEADERS = {
+    XML: { 'Content-Type': 'application/xml' },
+    JSON: { 'Content-Type': 'application/json', 'Accept': 'application/json' },
+    PLAIN: { 'Accept': 'text/plain' },
+  } as const;
+
+  /**
+   * Jenkins plugin information
+   */
+  public static readonly PLUGINS = {
+    WORKFLOW_JOB: 'workflow-job@2.40',
+    GITHUB: 'github@1.37.1',
+    WORKFLOW_CPS: 'workflow-cps@2.89',
+    GIT: 'git@4.4.5',
+    PLAIN_CREDENTIALS: 'plain-credentials',
+  } as const;
+
+  /**
+   * Jenkins API endpoints
+   */
+  public static readonly ENDPOINTS = {
+    CREATE_ITEM: 'createItem',
+    API_JSON: 'api/json',
+    BUILD: 'build',
+    BUILD_WITH_PARAMETERS: 'buildWithParameters',
+    LOG_TEXT: 'logText/progressiveText',
+    CREDENTIALS_STORE_SYSTEM: 'credentials/store/system/domain/_/createCredentials',
+    CREDENTIALS_STORE_FOLDER: 'credentials/store/folder/domain/_/createCredentials',
+  } as const;
+} 

src/api/ci/jenkins/enums/jenkins.enums.ts

@@ -0,0 +1,31 @@
+/**
+ * Jenkins build result status enum
+ */
+export enum JenkinsBuildResult {
+  SUCCESS = 'SUCCESS',
+  FAILURE = 'FAILURE',
+  UNSTABLE = 'UNSTABLE',
+  ABORTED = 'ABORTED',
+  NOT_BUILT = 'NOT_BUILT',
+}
+
+/**
+ * Jenkins build trigger type enum
+ */
+export enum JenkinsBuildTrigger {
+  UNKNOWN = 'UNKNOWN',
+  PULL_REQUEST = 'PULL_REQUEST',
+  PUSH = 'PUSH',
+  MANUAL = 'MANUAL',
+  SCHEDULED = 'SCHEDULED',
+  API = 'API',
+}
+
+/**
+ * Jenkins credential types
+ */
+export enum CredentialType {
+  SECRET_TEXT = 'Secret text',
+  USERNAME_PASSWORD = 'Username with password',
+  SSH_USERNAME_PRIVATE_KEY = 'SSH Username with private key',//TODO: need to confirm if this is correct
+}