@codex-ts/core-lib 1.0.0

package/dist/core-lib/lib/services/http-utility.service.d.ts

@@ -0,0 +1,130 @@
+import { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { MessageService } from 'primeng/api';
+import * as i0 from "@angular/core";
+/**
+ * A general-purpose HTTP utility service that provides enhanced HTTP operations
+ * beyond the standard Angular HttpClient. This service includes features such as:
+ * - Loading state management
+ * - Standardized error handling
+ * - Request timeouts and retries
+ * - File upload capabilities
+ * - Batch request handling
+ */
+export declare class HttpUtilityService {
+    private http;
+    private messageService?;
+    private loading;
+    loading$: Observable<boolean>;
+    constructor(http: HttpClient, messageService?: MessageService);
+    /**
+     * Perform a GET request with enhanced options
+     * @param url The endpoint URL
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    get<T>(url: string, options?: {
+        params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>;
+        headers?: HttpHeaders | Record<string, string | string[]>;
+        responseType?: 'json';
+        withCredentials?: boolean;
+        retries?: number;
+        timeoutMs?: number;
+    }): Observable<T>;
+    /**
+     * Perform a POST request with enhanced options
+     * @param url The endpoint URL
+     * @param body The request payload
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    post<T>(url: string, body: any, options?: {
+        params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>;
+        headers?: HttpHeaders | Record<string, string | string[]>;
+        responseType?: 'json';
+        withCredentials?: boolean;
+        retries?: number;
+        timeoutMs?: number;
+    }): Observable<T>;
+    /**
+     * Perform a PUT request with enhanced options
+     * @param url The endpoint URL
+     * @param body The request payload
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    put<T>(url: string, body: any, options?: {
+        params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>;
+        headers?: HttpHeaders | Record<string, string | string[]>;
+        responseType?: 'json';
+        withCredentials?: boolean;
+        retries?: number;
+        timeoutMs?: number;
+    }): Observable<T>;
+    /**
+     * Perform a DELETE request with enhanced options
+     * @param url The endpoint URL
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    delete<T>(url: string, options?: {
+        params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>;
+        headers?: HttpHeaders | Record<string, string | string[]>;
+        responseType?: 'json';
+        withCredentials?: boolean;
+        retries?: number;
+        timeoutMs?: number;
+    }): Observable<T>;
+    /**
+     * Upload a file with optional additional data
+     * @param url The upload endpoint URL
+     * @param file The file to upload
+     * @param additionalData Additional form data to include
+     * @param options Additional request options
+     * @returns An observable of the response
+     */
+    uploadFile<T>(url: string, file: File, additionalData?: Record<string, any>, options?: {
+        headers?: HttpHeaders | Record<string, string | string[]>;
+        withCredentials?: boolean;
+        retries?: number;
+        timeoutMs?: number;
+        onProgress?: (percentage: number) => void;
+    }): Observable<T>;
+    /**
+     * Execute multiple HTTP requests in parallel
+     * @param requests Array of HTTP request observables
+     * @returns An observable that emits when all requests complete
+     */
+    batchRequests<T>(requests: Observable<T>[]): Observable<T[]>;
+    /**
+     * Download a file from the server
+     * @param url The file URL
+     * @param filename Optional filename to save as
+     * @param options Additional request options
+     */
+    downloadFile(url: string, filename?: string, options?: {
+        params?: HttpParams | Record<string, string | number | boolean | readonly (string | number | boolean)[]>;
+        headers?: HttpHeaders | Record<string, string | string[]>;
+        withCredentials?: boolean;
+        timeoutMs?: number;
+    }): Observable<Blob>;
+    /**
+     * Create parameter string from an object
+     * @param params Object containing parameters
+     * @returns HttpParams object
+     */
+    createParams(params: Record<string, any>): HttpParams;
+    /**
+     * Standardized error handler for HTTP requests
+     * @param error The HTTP error
+     * @returns An observable that errors with the processed error object
+     */
+    private handleError;
+    /**
+     * Display an error message using the message service
+     * @param message Error message to display
+     */
+    private showError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HttpUtilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HttpUtilityService>;
+}

package/dist/core-lib/lib/services/notification.service.d.ts

@@ -0,0 +1,13 @@
+import { MessageService } from 'primeng/api';
+import * as i0 from "@angular/core";
+export declare class NotificationService {
+    private messageService;
+    private messageSubject;
+    message$: import("rxjs").Observable<any>;
+    constructor(messageService: MessageService);
+    showSuccess(message: string): void;
+    showError(message: string): void;
+    clearMessage(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
+}

package/dist/core-lib/lib/services/reference-data-provider.service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class ReferenceDataProviderService {
+    private endpoints;
+    setEndpoints(endpoints: Record<string, string>): void;
+    getReferenceEndpoint(entityName: string): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReferenceDataProviderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReferenceDataProviderService>;
+}

package/dist/core-lib/lib/services/utils.service.d.ts

@@ -0,0 +1,72 @@
+import { MessageService } from 'primeng/api';
+import * as i0 from "@angular/core";
+/**
+ * A utility service that provides common reusable functionality
+ * such as UUID validation and error message display
+ */
+export declare class UtilsService {
+    /**
+     * Validates if a string is a valid UUID
+     * @param uuid The string to validate
+     * @returns boolean indicating if the string is a valid UUID
+     */
+    isValidUUID(uuid: string): boolean;
+    /**
+     * Shows an error message using PrimeNG's MessageService
+     * @param message The error message to display
+     * @param messageService The MessageService instance to use
+     */
+    showError(message: string, messageService?: MessageService): void;
+    /**
+     * Shows a success message using PrimeNG's MessageService
+     * @param message The success message to display
+     * @param messageService The MessageService instance to use
+     */
+    showSuccess(message: string, messageService?: MessageService): void;
+    /**
+     * Gets the display value for an enum key or array of enum keys
+     * @param enumType The enum type
+     * @param key The enum key or array of enum keys
+     * @returns The display value for the enum key or comma-separated list of display values for array of keys
+     */
+    getEnumValue<T>(enumType: T, key: string | string[]): string;
+    /**
+     * Gets all values from an enum type for use in formly select fields
+     * @param enumType The enum type to get values from
+     * @returns Array of {label, value} pairs for formly select options
+     */
+    getEnumValues<T extends {
+        [key: string]: string | number;
+    }>(enumType: T): Array<{
+        label: string;
+        value: string;
+    }>;
+    /**
+     * Converts a camelCase string to Title Case with spaces
+     * @param camelCase The camelCase string to convert
+     * @returns The Title Case string
+     */
+    camelCaseToTitleCase(camelCase: string): string;
+    /**
+     * Converts a string to kebab-case
+     * @param input The string to convert
+     * @returns The kebab-case string
+     */
+    toKebabCase(input: string): string;
+    /**
+     * Converts a string to camelCase.
+     * Example: "loan-application" becomes "loanApplication"
+     * @param input The string to convert
+     * @returns The camelCase string
+     */
+    toCamelCase(input: string): string;
+    /**
+     * Removes double forward slashes from an endpoint string while preserving the protocol
+     * e.g. "http://localhost:8080//api//v1//users" -> "http://localhost:8080/api/v1/users"
+     * @param endpoint The endpoint string to clean
+     * @returns The cleaned endpoint string without double slashes
+     */
+    removeDoubleSlashes(endpoint: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
+}

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/@codex-ts/core-lib",
+  "lib": {
+    "entryFile": "src/index.ts"
+  }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@codex-ts/core-lib",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "build": "ng-packagr -p ng-package.json"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {
+    "@angular/animations": "^19.1.5",
+    "@angular/common": "^19.1.5",
+    "@angular/compiler": "^19.1.5",
+    "@angular/core": "^19.1.5",
+    "@angular/forms": "^19.1.5",
+    "@angular/platform-browser": "^19.1.5",
+    "@angular/platform-browser-dynamic": "^19.1.5",
+    "@angular/router": "^19.1.5",
+    "@angular/cdk": "^19.1.5",
+    "@ngx-formly/core": "^6.3.12",
+    "@primeng/themes": "^19.0.6",
+    "primeflex": "^3.3.1",
+    "primeicons": "^7.0.0",
+    "primeng": "^19.0.6",
+    "rxjs": "~7.8.0",
+    "zone.js": "~0.15.0"
+  },
+  "devDependencies": {
+    "@angular-devkit/build-angular": "^19.1.6",
+    "@angular/cli": "^19.0.6",
+    "@angular/compiler-cli": "^19.1.5",
+    "@types/jasmine": "~5.1.0",
+    "jasmine-core": "~5.4.0",
+    "karma": "~6.4.0",
+    "karma-chrome-launcher": "~3.2.0",
+    "karma-coverage": "~2.2.0",
+    "karma-jasmine": "~5.1.0",
+    "karma-jasmine-html-reporter": "~2.1.0",
+    "ng-packagr": "^19.1.0",
+    "typescript": "~5.6.2",
+    "@angular/animations": "^19.1.5",
+    "@angular/common": "^19.1.5",
+    "@angular/compiler": "^19.1.5",
+    "@angular/core": "^19.1.5",
+    "@angular/forms": "^19.1.5",
+    "@angular/platform-browser": "^19.1.5",
+    "@angular/platform-browser-dynamic": "^19.1.5",
+    "@angular/router": "^19.1.5",
+    "@angular/cdk": "^19.1.5",
+    "@ngx-formly/core": "^6.3.12",
+    "@primeng/themes": "^19.0.6",
+    "primeflex": "^3.3.1",
+    "primeicons": "^7.0.0",
+    "primeng": "^19.0.6",
+    "rxjs": "~7.8.0",
+    "zone.js": "~0.15.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+// Config
+
+// Services
+export * from './lib/services/formly-config.service';
+export * from './lib/services/utils.service';
+export * from './lib/services/notification.service';
+export * from './lib/services/enum-registry.service';
+export * from './lib/services/entity-registry.service';
+export * from './lib/services/reference-data-provider.service';
+export * from './lib/services/base-crud.service';
+export * from './lib/services/http-utility.service';
+export * from './lib/services/entity.service';
+
+// Enums
+export * from './lib/enums/component-context.enum';
+export * from './lib/enums/tabbed-form-type.enum';
+
+// Components
+export * from './lib/components/base-form.component';
+export * from './lib/components/base-page.component';
+export * from './lib/components/base-list-page.component';
+export * from './lib/components/base-tabbed-form.component';
+
+// Constants
+export * from './lib/constants/app.constants';
+export * from './lib/constants/app.messages';
+
+// Models
+export * from './lib/models/pagination/page.interface';
+export * from './lib/models/pagination/page-request.interface';
+
+// Pipes
+export * from './lib/pipes/indian-date.pipe';
+
+// Formly Components
+export * from './lib/components/formly/core-formly.module';
+export * from './lib/components/formly/form-field.wrapper';
+export * from './lib/components/formly/types/text-input.type';
+export * from './lib/components/formly/types/select.type';
+export * from './lib/components/formly/types/radio.type';
+export * from './lib/components/formly/types/numeric-input.type';
+export * from './lib/components/formly/types/multiselect.type';
+export * from './lib/components/formly/types/date.type';
+export * from './lib/components/formly/types/checkbox.type';

package/src/lib/components/base-form.component.ts

@@ -0,0 +1,328 @@
+import { Component, OnInit, Injectable, Input } from '@angular/core';
+import { ComponentContext } from '../enums/component-context.enum';
+import { FormGroup } from '@angular/forms';
+import { ActivatedRoute, Router } from '@angular/router';
+import { FormlyFieldConfig } from '@ngx-formly/core';
+import { BasePageComponent } from './base-page.component';
+import { UtilsService } from '../services/utils.service';
+import { NotificationService } from '../services/notification.service';
+import { AppMessages } from '../constants/app.messages';
+import { AppConstants, PageMode } from '../constants/app.constants';
+import { Observable, filter, take } from 'rxjs';
+import { FormlyConfigService } from '../services/formly-config.service';
+import { EntityService } from '../services/entity.service';
+
+@Injectable()
+@Component({
+    template: ''
+})
+export abstract class BaseFormComponent<T extends { uuid: string }>
+    extends BasePageComponent implements OnInit {
+
+    form = new FormGroup({});
+    fields: FormlyFieldConfig[] = [];
+    isNew = true;
+    mode: PageMode = AppConstants.PAGE_MODE.CREATE;
+    currentFormData: any = {};
+    protected originalFormData: T | null = null;
+    protected hasChanges: boolean = false;
+    @Input() context: ComponentContext = ComponentContext.STANDALONE;
+
+    constructor(
+        protected route: ActivatedRoute,
+        protected router: Router,
+        protected override notificationService: NotificationService,
+        protected override utilsService: UtilsService,
+        protected formlyConfigService: FormlyConfigService
+    ) {
+        super(utilsService, notificationService);
+    }
+
+    ngOnInit() {
+        try {
+            this.fields = this.getFormlyFieldConfig();
+
+            this.form.valueChanges.subscribe(() => {
+                console.log('[BaseFormComponent] Form value changed:', this.form.value);
+                this.currentFormData = { ...this.form.value };
+                this.hasChanges = this.hasFormChanges(this.currentFormData);
+            });
+
+            // Use queryParams instead of params
+            this.route.queryParams.pipe(take(1)).subscribe({
+                next: params => this.initializeForm(params),
+                error: error => {
+                    console.error('Error initializing form:', error);
+                    this.showError(AppMessages.FORM.ERROR.INIT);
+                }
+            });
+        } catch (error) {
+            console.error('Error in ngOnInit:', error);
+            this.showError(AppMessages.FORM.ERROR.INIT);
+        }
+    }
+
+    private initializeFormData() {
+        console.log('[BaseFormComponent] Initializing form data');
+        console.log('[BaseFormComponent] Current mode:', this.mode);
+
+        if (this.mode === AppConstants.PAGE_MODE.CREATE) {
+            console.log('[BaseFormComponent] Create mode, using defaults');
+            return;
+        }
+
+        const state = {
+            ...this.router.getCurrentNavigation()?.extras?.state,
+            ...window.history.state,
+            ...this.route.snapshot.data
+        };
+        console.log('[BaseFormComponent] Combined state:', state);
+        console.log('[BaseFormComponent] Final state being used:', state);
+        
+        if (state && 'formData' in state) {
+            console.log('[BaseFormComponent] Found form data in state:', state['formData']);
+            this.patchFormData(state['formData']);
+        } else {
+            console.log('[BaseFormComponent] No form data, loading from UUID');
+            this.loadFromUuid();
+        }
+    }
+
+    private loadFromUuid() {
+        this.route.queryParams.pipe(take(1)).subscribe(params => {
+            const uuid = params[AppConstants.FORM.UUID];
+            if (!uuid) {
+                throw new Error(`UUID is required for ${this.mode} mode when no formData is provided`);
+            }
+            this.loadEntity(uuid);
+        });
+    }
+
+    private initializeForm(params: any) {
+        console.log('[BaseFormComponent] Initializing form with params:', params);
+        const routeMode = params[AppConstants.FORM.MODE];
+        this.initializeFormMode(routeMode);
+        this.setupFormState();
+
+        // Check for context in router state
+        const state = window.history.state;
+        if (state?.context) {
+            this.context = state.context;
+            console.log('[BaseFormComponent] Context set from router state:', this.context);
+        }
+
+        this.initializeFormData();
+    }
+
+    protected patchFormData(data: any) {
+        console.log('[BaseFormComponent] Patching form data:', data);
+        if (data) {
+            if (!this.fields || this.fields.length === 0) {
+                console.warn('[BaseFormComponent] Fields not initialized yet, reinitializing');
+                this.fields = this.getFormlyFieldConfig();
+            }
+            this.currentFormData = { ...data };
+            this.originalFormData = data;
+            this.isNew = false;
+            
+            console.log('[BaseFormComponent] Form data updated:', this.currentFormData);
+            console.log('[BaseFormComponent] Fields available:', this.fields);
+            
+            setTimeout(() => {
+                if (!this.form.valid) {
+                    console.warn('[BaseFormComponent] Form validation issues after data patch');
+                }
+                console.log('[BaseFormComponent] Form state after sync:', {
+                    valid: this.form.valid,
+                    values: this.form.value,
+                    currentData: this.currentFormData
+                });
+            }, 100);
+        }
+    }
+
+    private initializeFormMode(routeMode: string | undefined) {
+        if (!routeMode) {
+            this.mode = AppConstants.PAGE_MODE.CREATE;
+        } else if (this.isValidPageMode(routeMode)) {
+            this.mode = routeMode;
+        } else {
+            throw new Error(`Invalid page mode: ${routeMode}`);
+        }
+    }
+
+    private setupFormState() {
+        console.log('[BaseFormComponent] Setting up form state, mode:', this.mode);
+        this.fields = this.getFormlyFieldConfig();
+
+        if (this.mode === AppConstants.PAGE_MODE.CREATE) {
+            console.log('[BaseFormComponent] Create mode setup');
+            this.isNew = true;
+            this.loading = false;
+            this.originalFormData = null;
+        }
+
+        if (this.mode === AppConstants.PAGE_MODE.VIEW) {
+            console.log('[BaseFormComponent] View mode setup');
+            this.form.disable();
+        }
+    }
+
+    protected getFormlyFieldConfig(): FormlyFieldConfig[] {
+        return this.formlyConfigService.getFormConfig(
+            this.getJsonFields(),
+            this.mode,
+            this.getDropdownOptions()
+        );
+    }
+
+    protected onSubmitRoute(): string[] {
+        return [`/${this.getEntityName().toLowerCase()}s`];
+    }
+
+    protected getEntityOperations(): {
+        create: (data: Omit<T, typeof AppConstants.FORM.UUID>) => Observable<T>;
+        update: (uuid: string, data: Omit<T, typeof AppConstants.FORM.UUID>) => Observable<T>;
+        getById: (uuid: string) => Observable<T>;
+    } {
+        const entityService = this.getEntityService();
+        return {
+            create: (data) => entityService.create(data),
+            update: (uuid, data) => entityService.update(uuid, { ...data, uuid } as T),
+            getById: (uuid) => entityService.getById(uuid)
+        };
+    }
+
+    protected onSubmit() {
+        console.log('[BaseFormComponent] Form submission:', {
+            formValid: this.form.valid,
+            formData: this.currentFormData,
+            formState: this.form.value
+        });
+
+        if (!this.currentFormData || Object.keys(this.currentFormData).length === 0) {
+            this.notificationService.showError('No data to save');
+            return;
+        }
+
+        if (this.form.valid) {
+            if (this.isNew) {
+                console.log('[BaseFormComponent] Saving new entity');
+                this.saveEntity();
+                return;
+            }
+
+            const hasChanges = this.hasFormChanges(this.currentFormData);
+            console.log('[BaseFormComponent] Change detection:', {
+                hasChanges,
+                currentData: this.currentFormData,
+                originalData: this.originalFormData
+            });
+
+            if (!hasChanges) {
+                this.notificationService.showSuccess('No changes to save');
+                return;
+            }
+
+            console.log('[BaseFormComponent] Saving changes');
+            this.saveEntity();
+        } else {
+            console.warn('[BaseFormComponent] Form validation failed:', this.form.errors);
+            this.notificationService.showError('Please check form errors');
+        }
+    }
+
+    protected hasFormChanges(currentData: any): boolean {
+        if (!this.originalFormData || this.isNew) {
+            return true;
+        }
+
+        console.log('[BaseFormComponent] Checking for changes:', {
+            currentData,
+            originalData: this.originalFormData
+        });
+
+        const hasChanges = Object.keys(currentData).some(key => {
+            const currentValue = currentData[key];
+            const originalValue = (this.originalFormData as any)[key];
+            const changed = currentValue !== originalValue;
+            
+            if (changed) {
+                console.log(`[BaseFormComponent] Field '${key}' changed:`, {
+                    from: originalValue,
+                    to: currentValue
+                });
+            }
+            
+            return changed;
+        });
+
+        console.log('[BaseFormComponent] Changes detected:', hasChanges);
+        return hasChanges;
+    }
+
+    protected saveEntity() {
+        this.loading = true;
+        const formData = this.currentFormData as Omit<T, typeof AppConstants.FORM.UUID>;
+        const entityName = this.getEntityName();
+        const entityOperations = this.getEntityOperations();
+
+        const request$ = this.isNew
+            ? entityOperations.create(formData)
+            : entityOperations.update(this.originalFormData!.uuid, formData);
+
+        request$.subscribe({
+            next: () => {
+                this.loading = false;
+                this.notificationService.showSuccess(`${entityName} ${AppMessages.FORM.SUCCESS.SAVE}`);
+                this.router.navigate(this.onSubmitRoute());
+            },
+            error: (error: any) => {
+                const errorMessage = error.error?.message || `${AppMessages.FORM.ERROR.SAVE} ${entityName}`;
+                this.showError(errorMessage);
+                this.loading = false;
+            }
+        });
+    }
+
+    protected loadEntity(uuid: string) {
+        this.loading = true;
+        this.isNew = false;
+        const entityName = this.getEntityName();
+
+        this.getEntityOperations().getById(uuid).subscribe({
+            next: (data: T) => {
+                this.originalFormData = data;
+                this.currentFormData = { ...data };
+                this.loading = false;
+                console.log('[BaseFormComponent] Original data loaded:', this.originalFormData);
+                console.log('[BaseFormComponent] Form data updated:', this.currentFormData);
+            },
+            error: () => {
+                this.showError(`${AppMessages.FORM.ERROR.LOAD} ${entityName}`);
+                this.loading = false;
+            }
+        });
+    }
+
+    protected abstract getEntityService(): EntityService<T>;
+
+    private isValidPageMode(mode: string): mode is PageMode {
+        return Object.values(AppConstants.PAGE_MODE).includes(mode as PageMode);
+    }
+
+    protected getDropdownOptions(): Record<string, any> {
+        return {};
+    }
+
+    protected abstract getJsonFields(): any;
+    protected abstract getEntityName(): string;
+
+    /**
+     * Checks if the component is running in a specific context
+     * @param contextType The context type to check against
+     */
+    protected isInContext(contextType: ComponentContext): boolean {
+        return this.context === contextType;
+    }
+}