@codex-ts/core-lib 1.0.0

package/src/lib/constants/app.messages.ts

@@ -0,0 +1,36 @@
+export const AppMessages = {
+    COMMON: {
+        ERROR: {
+            GENERAL: 'An error occurred',
+            INVALID_INPUT: 'Invalid input provided',
+            REQUIRED_FIELD: 'This field is required'
+        },
+        SUCCESS: {
+            SAVE: 'saved successfully',
+            UPDATE: 'updated successfully',
+            DELETE: 'deleted successfully'
+        }
+    },
+    FORM: {
+        ERROR: {
+            INIT: 'Failed to initialize form',
+            SAVE: 'Failed to save',
+            LOAD: 'Failed to load',
+            VALIDATION: 'Please fill in all required fields correctly'
+        },
+        SUCCESS: {
+            SAVE: 'saved successfully'
+        }
+    },
+    LIST: {
+        ERROR: {
+            LOAD: 'Failed to load',
+            DELETE: 'Failed to delete',
+            NAVIGATION: 'Navigation failed',
+            INVALID_ID: 'Cannot perform action without ID'
+        },
+        SUCCESS: {
+            DELETE: 'deleted successfully'
+        }
+    }
+} as const;

package/src/lib/enums/component-context.enum.ts

@@ -0,0 +1,6 @@
+export enum ComponentContext {
+  STANDALONE = 'STANDALONE',
+  TABBED = 'TABBED',
+  MODAL = 'MODAL',
+  EMBEDDED = 'EMBEDDED'
+}

package/src/lib/enums/tabbed-form-type.enum.ts

@@ -0,0 +1,4 @@
+export enum TabbedFormType {
+    STANDARD = 'STANDARD',
+    LIST = 'LIST'
+}

package/src/lib/models/pagination/filter-criteria.interface.ts

@@ -0,0 +1,19 @@
+/**
+ * Matches backend FilterCriteria and FilterOperator
+ */
+export type FilterOperator = 
+    | 'EQUALS'
+    | 'NOT_EQUALS'
+    | 'CONTAINS'
+    | 'STARTS_WITH'
+    | 'ENDS_WITH'
+    | 'LESS_THAN'
+    | 'LESS_THAN_EQUALS'
+    | 'GREATER_THAN'
+    | 'GREATER_THAN_EQUALS';
+
+export interface FilterCriteria {
+    field: string;
+    value: string;  // Backend expects all values as strings
+    operator: FilterOperator;
+}

package/src/lib/models/pagination/page-request.interface.ts

@@ -0,0 +1,13 @@
+import { FilterCriteria } from './filter-criteria.interface';
+import { SortCriteria } from './sort-criteria.interface';
+
+export interface PageRequest {
+    page?: number;
+    size?: number;
+    sorts?: SortCriteria[];
+    filters?: FilterCriteria[];
+}
+
+// Re-export for convenience
+export type { FilterCriteria } from './filter-criteria.interface';
+export type { SortCriteria } from './sort-criteria.interface';

package/src/lib/models/pagination/page.interface.ts

@@ -0,0 +1,9 @@
+export interface Page<T> {
+    content: T[];
+    page:{
+        totalElements: number;
+        totalPages: number;
+        size: number;
+        number: number;
+    }
+}

package/src/lib/models/pagination/sort-criteria.interface.ts

@@ -0,0 +1,4 @@
+export interface SortCriteria {
+  field: string;
+  direction: 'asc' | 'desc';
+}

package/src/lib/pipes/indian-date.pipe.ts

@@ -0,0 +1,46 @@
+import { Pipe, PipeTransform } from '@angular/core';
+import { DatePipe } from '@angular/common';
+
+type DateFormat = 'default' | 'short' | 'medium';
+
+@Pipe({
+    name: 'indianDate',
+    standalone: true
+})
+export class IndianDatePipe implements PipeTransform {
+    constructor(private datePipe: DatePipe) {}
+
+    transform(value: string | null, format: DateFormat = 'default'): string | null {
+        if (!value) return null;
+
+        // First validate dd-MM-yyyy format
+        const dateRegex = /^(0[1-9]|[12][0-9]|3[01])-(0[1-9]|1[0-2])-\d{4}$/;
+        if (!dateRegex.test(value)) {
+            throw new Error(`Invalid date format: ${value}. Expected format: dd-MM-yyyy`);
+        }
+
+        // Validate real date
+        const [day, month, year] = value.split('-').map(Number);
+        const date = new Date(year, month - 1, day);
+        if (
+            date.getFullYear() !== year ||
+            date.getMonth() !== month - 1 ||
+            date.getDate() !== day
+        ) {
+            throw new Error(`Invalid date: ${value}`);
+        }
+
+        // Apply requested format
+        switch (format) {
+            case 'short':
+                // Pad with leading zeros for consistent format
+                const paddedDay = day.toString().padStart(2, '0');
+                const paddedMonth = month.toString().padStart(2, '0');
+                return `${paddedDay}-${paddedMonth}-${year}`; // 10-03-2025
+            case 'medium':
+                return this.datePipe.transform(date, 'dd MMM yyyy'); // 10 Jan 2019
+            default:
+                return value; // original dd-MM-yyyy
+        }
+    }
+}

package/src/lib/services/base-crud.service.ts

@@ -0,0 +1,81 @@
+import { HttpParams, HttpErrorResponse } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { HttpUtilityService } from './http-utility.service';
+import { UtilsService } from './utils.service';
+import { MessageService } from 'primeng/api';
+import { Page } from '../models/pagination/page.interface';
+import { PageRequest } from '../models/pagination/page-request.interface';
+import { EntityService } from './entity.service';
+
+export abstract class BaseCrudService<T extends { uuid: string }> implements EntityService<T> {
+  // Use the loading state from HttpUtilityService
+  get loading$() {
+    return this.httpUtility.loading$;
+  }
+
+  protected apiUrl: string;
+
+  /**
+   * Creates an instance of BaseCrudService.
+   * @param httpUtility - Service for making HTTP requests
+   * @param utilsService - Utility service for common operations
+   * @param resourcePath - API resource path (e.g., 'customers', 'products')
+   * @param backendBaseUrl - Base URL for the backend API
+   * @param messageService - Optional service for showing messages
+   */
+  protected constructor(
+    protected httpUtility: HttpUtilityService,
+    protected utilsService: UtilsService,
+    protected resourcePath: string,
+    protected backendBaseUrl: string,
+    protected messageService: MessageService | undefined
+  ) {
+    this.apiUrl = this.joinUrls(backendBaseUrl, resourcePath);
+  }
+
+  /**
+   * Joins URL parts ensuring no double slashes
+   */
+  private joinUrls(...parts: string[]): string {
+    return parts.map(part => part.replace(/^\/+|\/+$/g, '')).join('/');
+  }
+
+  getAll(pageRequest?: PageRequest): Observable<Page<T>> {
+    if (pageRequest) {
+      return this.httpUtility.post<Page<T>>(`${this.apiUrl}/page`, pageRequest);
+    } else {
+      return this.httpUtility.get<Page<T>>(this.apiUrl);
+    }
+  }
+
+  getById(uuid: string): Observable<T> {
+    if (!this.utilsService.isValidUUID(uuid)) {
+      this.utilsService.showError('Invalid UUID format', this.messageService);
+      return throwError(() => new Error('Invalid UUID format'));
+    }
+
+    return this.httpUtility.get<T>(`${this.apiUrl}/${uuid}`);
+  }
+
+  create(entity: Omit<T, 'uuid'>): Observable<T> {
+    return this.httpUtility.post<T>(this.apiUrl, entity);
+  }
+
+  update(uuid: string, entity: Omit<T, 'uuid'>): Observable<T> {
+    if (!this.utilsService.isValidUUID(uuid)) {
+      this.utilsService.showError('Invalid UUID format', this.messageService);
+      return throwError(() => new Error('Invalid UUID format'));
+    }
+
+    return this.httpUtility.put<T>(`${this.apiUrl}/${uuid}`, entity);
+  }
+
+  delete(uuid: string): Observable<void> {
+    if (!this.utilsService.isValidUUID(uuid)) {
+      this.utilsService.showError('Invalid UUID format', this.messageService);
+      return throwError(() => new Error('Invalid UUID format'));
+    }
+
+    return this.httpUtility.delete<void>(`${this.apiUrl}/${uuid}`);
+  }
+}

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

@@ -0,0 +1,51 @@
+import { Injectable } from '@angular/core';
+import { Observable, map } from 'rxjs';
+import { HttpUtilityService } from './http-utility.service';
+import { ReferenceDataProviderService } from './reference-data-provider.service';
+
+export interface ReferenceDto {
+    key: string;
+    displayLabel: string;
+    data?: any;
+}
+
+@Injectable({
+    providedIn: 'root'
+})
+export class EntityRegistryService {
+  constructor(
+    private httpUtility: HttpUtilityService,
+    private dataProvider: ReferenceDataProviderService
+  ) {}
+
+  /**
+   * Gets reference options for an entity, suitable for select/dropdown components
+   * @param entityName The name of the entity (e.g., 'customers', 'departments')
+   * @returns Observable of options array with label/value pairs
+   */
+  getEntityOptions(entityName: string): Observable<{ label: string; value: string; data?: any; }[]> {
+    console.log('getEntityOptions', entityName);
+    const url = this.dataProvider.getReferenceEndpoint(entityName);
+
+    if (!url) {
+      console.warn(`No endpoint configured for entity: ${entityName}`);
+      return new Observable(subscriber => {
+        subscriber.next([]);
+        subscriber.complete();
+      });
+    }
+
+    return this.httpUtility.get<ReferenceDto[]>(url, {
+      retries: 1,
+      timeoutMs: 10000,
+    }).pipe(
+      map((items) =>
+        items?.map((item) => ({
+          label: item.displayLabel,
+          value: item.key,
+          data: item.data,
+        })) || []
+      )
+    );
+  }
+}

package/src/lib/services/entity.service.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+
+/**
+ * Interface for basic CRUD operations that all entity services must implement
+ */
+export interface EntityService<T> {
+    create(data: Omit<T, 'uuid'>): Observable<T>;
+    update(uuid: string, data: Omit<T, 'uuid'>): Observable<T>;
+    getById(uuid: string): Observable<T>;
+}

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;
+        }
+      });
+  }
+}