@codex-ts/core-lib 1.0.1 → 1.0.2

package/src/lib/services/enum-registry.service.ts

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import { UtilsService } from './utils.service';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class EnumRegistryService {
+    private enumMap = new Map<string, any>();
+
+    constructor(private utilsService: UtilsService) {}
+
+    /**
+     * Initialize global enums
+     */
+    static registerGlobalEnums(enums: Record<string, any>) {
+        return {
+            provide: EnumRegistryService,
+            useFactory: (utilsService: UtilsService) => {
+                const service = new EnumRegistryService(utilsService);
+                Object.entries(enums).forEach(([name, enumType]) => {
+                    service.register(name, enumType);
+                });
+                return service;
+            },
+            deps: [UtilsService]
+        };
+    }
+    
+    /**
+     * Register an enum type with the service
+     * @param name Name to register the enum under
+     * @param enumType The enum type to register
+     */
+    register(name: string, enumType: any) {
+        this.enumMap.set(name, enumType);
+    }
+    
+    /**
+     * Get formly-compatible options array for a registered enum
+     * @param name Name of the registered enum
+     * @returns Array of {label, value} pairs suitable for formly select fields
+     */
+    getEnumValues(name: string) {
+        const enumType = this.enumMap.get(name);
+        if (!enumType) {
+            console.warn(`Enum type "${name}" not found in registry`);
+            return [];
+        }
+        return this.utilsService.getEnumValues(enumType);
+    }
+
+    /**
+     * Check if an enum type is registered
+     * @param name Name of the enum to check
+     */
+    hasEnum(name: string): boolean {
+        return this.enumMap.has(name);
+    }
+
+    /**
+     * Clear all registered enums
+     */
+    clear() {
+        this.enumMap.clear();
+    }
+}

package/src/lib/services/formly-config.service.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { PageMode } from '../constants/app.constants';
+import { EnumRegistryService } from './enum-registry.service';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class FormlyConfigService {
+    constructor(private enumRegistry: EnumRegistryService) {}
+
+    getFormConfig(
+        fields: FormlyFieldConfig[], 
+        mode: PageMode,
+        dynamicOptions?: Record<string, any>
+    ): FormlyFieldConfig[] {
+        const commonConfig = {
+            props: {
+                disabled: mode === 'view'
+            }
+        };
+
+        return fields.map((field: FormlyFieldConfig) => {
+            // Apply dynamic options from child component
+            if (dynamicOptions && field.key && typeof field.key === 'string') {
+                const fieldOptions = dynamicOptions[field.key];
+                if (fieldOptions) {
+                    field.props = {
+                        ...field.props,
+                        ...fieldOptions
+                    };
+                }
+            }
+
+            // Handle field groups recursively
+            if (field.fieldGroup) {
+                field.fieldGroup = this.getFormConfig(field.fieldGroup, mode, dynamicOptions);
+            }
+
+            return {
+                ...field,
+                ...commonConfig,
+                props: {
+                    ...field.props,
+                    ...commonConfig.props
+                }
+            };
+        });
+    }
+}

package/src/lib/services/http-utility.service.example.ts

@@ -0,0 +1,253 @@
+import { Component, OnInit } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { HttpUtilityService } from './http-utility.service';
+
+/**
+ * Example component showing how to use the HttpUtilityService
+ * This is just a demonstration and not an actual component to use.
+ */
+@Component({
+  selector: 'app-http-utility-example',
+  template: `
+    <div>
+      <h2>HTTP Utility Service Example</h2>
+      <div *ngIf="loading">Loading...</div>
+      <div *ngIf="user">
+        <p>User ID: {{ user.id }}</p>
+        <p>Name: {{ user.name }}</p>
+        <p>Email: {{ user.email }}</p>
+      </div>
+      <div *ngIf="errorMessage" class="error">{{ errorMessage }}</div>
+      <button (click)="loadUser()">Load User</button>
+      <button (click)="createUser()">Create User</button>
+      <button (click)="updateUser()">Update User</button>
+      <button (click)="deleteUser()">Delete User</button>
+      <button (click)="uploadUserPhoto()">Upload Photo</button>
+      <button (click)="loadMultipleResources()">Load Multiple Resources</button>
+      <button (click)="downloadReport()">Download Report</button>
+    </div>
+  `
+})
+export class HttpUtilityExampleComponent implements OnInit {
+  loading = false;
+  user: any;
+  errorMessage = '';
+
+  // Make sure to inject the service in the constructor
+  constructor(private httpUtility: HttpUtilityService) {
+    // Subscribe to the loading state observable
+    this.httpUtility.loading$.subscribe(isLoading => {
+      this.loading = isLoading;
+    });
+  }
+
+  ngOnInit(): void {
+    // Initial data loading
+    this.loadUser();
+  }
+
+  /**
+   * Example of a GET request with parameters
+   */
+  loadUser(): void {
+    // Clear previous error messages
+    this.errorMessage = '';
+    
+    // Creating parameters with the utility method
+    const params = this.httpUtility.createParams({
+      id: '12345',
+      includeDetails: true
+    });
+    
+    // Example API call with options
+    this.httpUtility.get<any>('/api/users/current', {
+      params,
+      retries: 3,
+      timeoutMs: 10000
+    }).subscribe({
+      next: (data) => {
+        console.log('User data loaded:', data);
+        this.user = data;
+      },
+      error: (error) => {
+        console.error('Error loading user:', error);
+        this.errorMessage = error.message;
+      }
+    });
+  }
+
+  /**
+   * Example of a POST request with custom headers
+   */
+  createUser(): void {
+    this.errorMessage = '';
+    
+    // Example user data
+    const newUser = {
+      name: 'John Doe',
+      email: 'john.doe@example.com',
+      role: 'user'
+    };
+    
+    // Custom headers
+    const headers = new HttpHeaders({
+      'X-Custom-Header': 'some-value'
+    });
+    
+    this.httpUtility.post<any>('/api/users', newUser, {
+      headers,
+      withCredentials: true
+    }).subscribe({
+      next: (response) => {
+        console.log('User created:', response);
+        this.user = response;
+      },
+      error: (error) => {
+        console.error('Error creating user:', error);
+        this.errorMessage = error.message;
+      }
+    });
+  }
+
+  /**
+   * Example of a PUT request
+   */
+  updateUser(): void {
+    if (!this.user) {
+      this.errorMessage = 'No user loaded to update';
+      return;
+    }
+    
+    const updatedUser = {
+      ...this.user,
+      name: 'Updated Name'
+    };
+    
+    this.httpUtility.put<any>(`/api/users/${this.user.id}`, updatedUser)
+      .subscribe({
+        next: (response) => {
+          console.log('User updated:', response);
+          this.user = response;
+        },
+        error: (error) => {
+          console.error('Error updating user:', error);
+          this.errorMessage = error.message;
+        }
+      });
+  }
+
+  /**
+   * Example of a DELETE request
+   */
+  deleteUser(): void {
+    if (!this.user) {
+      this.errorMessage = 'No user loaded to delete';
+      return;
+    }
+    
+    this.httpUtility.delete<void>(`/api/users/${this.user.id}`)
+      .subscribe({
+        next: () => {
+          console.log('User deleted successfully');
+          this.user = null;
+        },
+        error: (error) => {
+          console.error('Error deleting user:', error);
+          this.errorMessage = error.message;
+        }
+      });
+  }
+
+  /**
+   * Example of file upload with progress tracking
+   */
+  uploadUserPhoto(): void {
+    // In a real application, you would get this from a file input
+    // This is just for demonstration purposes
+    const file = new File(['dummy content'], 'profile-photo.jpg', { type: 'image/jpeg' });
+    
+    // Additional form data
+    const additionalData = {
+      userId: this.user?.id || 'unknown',
+      description: 'Profile photo'
+    };
+    
+    // Define the expected response type
+    interface PhotoUploadResponse {
+      photoUrl: string;
+      timestamp: string;
+      fileSize: number;
+    }
+    
+    this.httpUtility.uploadFile<PhotoUploadResponse>('/api/users/photo', file, additionalData, {
+      onProgress: (percentage) => {
+        console.log(`Upload progress: ${percentage}%`);
+        // Update UI with progress
+      }
+    }).subscribe({
+      next: (response) => {
+        console.log('Photo uploaded:', response);
+        // Update user with new photo URL
+        this.user = {
+          ...this.user,
+          photoUrl: response.photoUrl
+        };
+      },
+      error: (error) => {
+        console.error('Error uploading photo:', error);
+        this.errorMessage = error.message;
+      }
+    });
+  }
+
+  /**
+   * Example of batch requests
+   */
+  loadMultipleResources(): void {
+    // Create multiple requests
+    const userRequest = this.httpUtility.get<any>('/api/users/current');
+    const postsRequest = this.httpUtility.get<any[]>('/api/posts');
+    const notificationsRequest = this.httpUtility.get<any[]>('/api/notifications');
+    
+    // Execute all requests in parallel
+    this.httpUtility.batchRequests([
+      userRequest,
+      postsRequest,
+      notificationsRequest
+    ]).subscribe({
+      next: ([user, posts, notifications]) => {
+        console.log('All data loaded:', { user, posts, notifications });
+        this.user = user;
+        // Handle other data
+      },
+      error: (error) => {
+        console.error('Error loading batch data:', error);
+        this.errorMessage = error.message;
+      }
+    });
+  }
+
+  /**
+   * Example of file download
+   */
+  downloadReport(): void {
+    this.httpUtility.downloadFile('/api/reports/user-activity', 'user-activity.pdf')
+      .subscribe({
+        next: (blob) => {
+          // Create a download link and trigger it
+          const url = window.URL.createObjectURL(blob);
+          const a = document.createElement('a');
+          a.href = url;
+          a.download = 'user-activity.pdf';
+          document.body.appendChild(a);
+          a.click();
+          window.URL.revokeObjectURL(url);
+          a.remove();
+        },
+        error: (error) => {
+          console.error('Error downloading file:', error);
+          this.errorMessage = error.message;
+        }
+      });
+  }
+}

package/src/lib/services/http-utility.service.md

@@ -0,0 +1,175 @@
+# HttpUtilityService
+
+A general-purpose HTTP utility service that extends Angular's HttpClient with additional functionality for common HTTP operations.
+
+## Features
+
+- **Enhanced HTTP Methods**: Typed GET, POST, PUT, DELETE methods with additional options
+- **Loading State Management**: Built-in loading state tracking
+- **Error Handling**: Standardized error handling with message display
+- **Request Configuration**:
+  - Timeout configuration
+  - Retry capabilities
+  - Custom headers and params support
+- **Specialized Operations**:
+  - File uploads with progress tracking
+  - File downloads
+  - Batch request handling
+
+## Installation
+
+The service is part of the core library. It's already registered with the Angular DI system, so you can inject it directly into your components and services.
+
+## Usage
+
+### Basic Import
+
+```typescript
+import { HttpUtilityService } from '@core/core-lib';
+
+@Component({
+  // ...
+})
+export class MyComponent {
+  constructor(private httpUtil: HttpUtilityService) {}
+}
+```
+
+### GET Requests
+
+```typescript
+// Simple GET request
+this.httpUtil.get<UserData>('/api/users/123').subscribe({
+  next: (data) => console.log('User data:', data),
+  error: (err) => console.error('Error fetching user:', err)
+});
+
+// GET with parameters and options
+const params = this.httpUtil.createParams({
+  filter: 'active',
+  sort: 'name',
+  page: 1
+});
+
+this.httpUtil.get<PagedResponse<UserData>>('/api/users', {
+  params,
+  retries: 2,
+  timeoutMs: 5000
+}).subscribe({
+  next: (data) => this.handleData(data),
+  error: (err) => this.handleError(err)
+});
+```
+
+### POST Requests
+
+```typescript
+const newUser = {
+  name: 'John Doe',
+  email: 'john@example.com'
+};
+
+this.httpUtil.post<UserData>('/api/users', newUser).subscribe({
+  next: (data) => console.log('User created:', data),
+  error: (err) => console.error('Error creating user:', err)
+});
+```
+
+### PUT Requests
+
+```typescript
+const updatedUser = {
+  id: '123',
+  name: 'John Smith',
+  email: 'john@example.com'
+};
+
+this.httpUtil.put<UserData>(`/api/users/${updatedUser.id}`, updatedUser).subscribe({
+  next: (data) => console.log('User updated:', data),
+  error: (err) => console.error('Error updating user:', err)
+});
+```
+
+### DELETE Requests
+
+```typescript
+this.httpUtil.delete<void>('/api/users/123').subscribe({
+  next: () => console.log('User deleted successfully'),
+  error: (err) => console.error('Error deleting user:', err)
+});
+```
+
+### File Upload with Progress
+
+```typescript
+// Get file from a file input
+const fileInput = event.target.files[0];
+
+// Additional form data
+const metadata = {
+  description: 'Profile photo',
+  userId: '123'
+};
+
+this.httpUtil.uploadFile<{url: string}>('/api/upload', fileInput, metadata, {
+  onProgress: (percent) => this.uploadProgress = percent
+}).subscribe({
+  next: (response) => this.imageUrl = response.url,
+  error: (err) => console.error('Upload failed:', err)
+});
+```
+
+### File Download
+
+```typescript
+this.httpUtil.downloadFile('/api/reports/123', 'report.pdf').subscribe({
+  next: (blob) => {
+    // Create download link
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = 'report.pdf';
+    document.body.appendChild(a);
+    a.click();
+    window.URL.revokeObjectURL(url);
+    a.remove();
+  },
+  error: (err) => console.error('Download failed:', err)
+});
+```
+
+### Batch Requests
+
+```typescript
+// Create multiple requests
+const userRequest = this.httpUtil.get<UserData>('/api/users/123');
+const ordersRequest = this.httpUtil.get<Order[]>(`/api/users/123/orders`);
+
+// Execute all requests in parallel
+this.httpUtil.batchRequests([userRequest, ordersRequest]).subscribe({
+  next: ([user, orders]) => {
+    this.user = user;
+    this.orders = orders;
+  },
+  error: (err) => console.error('Error fetching data:', err)
+});
+```
+
+### Loading State
+
+The service exposes a loading state observable that you can subscribe to:
+
+```typescript
+this.httpUtil.loading$.subscribe(isLoading => {
+  this.isLoading = isLoading;
+  // Update UI based on loading state
+});
+```
+
+## Error Handling
+
+The service automatically handles common HTTP errors and displays appropriate messages using the MessageService if it's provided in the constructor.
+
+## Advanced Usage
+
+For more complex usage examples, see the `http-utility.service.example.ts` file.