@govish/shared-services 1.4.0 → 1.5.1

package/dist/services/apiKeyService.d.ts

@@ -13,6 +13,7 @@ export interface ApiKeyData {
 }
 export declare class ApiKeyService {
     private logger;
+    private redisClient;
     private safeRedisGet?;
     private safeRedisSet?;
     constructor(deps: SharedServicesDependencies);
@@ -27,7 +28,7 @@ export declare class ApiKeyService {
     createApiKey(microservice: string, description?: string, expiresInDays?: number, createdBy?: number): Promise<ApiKeyData>;
     /**
      * Validate an API key
-     * Uses Redis cache with auth service fallback (similar to officer service pattern)
+     * Uses Redis cache only (matches auth microservice cache format)
      */
     validateApiKey(apiKey: string): Promise<ApiKeyData | null>;
     /**

package/dist/services/apiKeyService.js

@@ -17,6 +17,7 @@ const crypto_1 = __importDefault(require("crypto"));
 class ApiKeyService {
     constructor(deps) {
         this.logger = deps.logger;
+        this.redisClient = deps.redisClient;
         this.safeRedisGet = deps.safeRedisGet;
         this.safeRedisSet = deps.safeRedisSet;
     }
@@ -74,72 +75,263 @@ class ApiKeyService {
     }
     /**
      * Validate an API key
-     * Uses Redis cache with auth service fallback (similar to officer service pattern)
+     * Uses Redis cache only (matches auth microservice cache format)
      */
     validateApiKey(apiKey) {
         return __awaiter(this, void 0, void 0, function* () {
+            const apiKeyPreview = apiKey.substring(0, 10) + '...'; // Show first 10 chars for logging
+            console.log('🔑 [API Key Validation] Step 1: Starting API key validation', {
+                apiKeyPreview,
+                timestamp: new Date().toISOString()
+            });
+            this.logger.info('[API Key Validation] Step 1: Starting API key validation', {
+                apiKeyPreview
+            });
             try {
-                // Try to get from Redis cache first
-                const cacheKey = `api_key:${apiKey}`;
-                const cachedData = this.safeRedisGet ? yield this.safeRedisGet(cacheKey) : null;
+                // Ensure Redis is connected
+                if (!this.redisClient.isOpen) {
+                    yield this.redisClient.connect();
+                }
+                // Step 2: Get API key ID from lookup key (matches auth microservice format)
+                console.log('🔍 [API Key Validation] Step 2: Checking Redis cache for API key');
+                this.logger.info('[API Key Validation] Step 2: Checking Redis cache for API key');
+                const lookupKey = `apikey:by_key:${apiKey}`;
+                const apiKeyIdStr = yield this.redisClient.get(lookupKey);
                 let key = null;
-                if (cachedData) {
-                    try {
-                        key = JSON.parse(cachedData);
-                        this.logger.debug('API key found in cache', { apiKeyId: key.id });
+                let cacheHit = false;
+                if (apiKeyIdStr) {
+                    // Step 3: Get API key hash data using the ID
+                    const apiKeyId = parseInt(apiKeyIdStr, 10);
+                    if (!isNaN(apiKeyId)) {
+                        cacheHit = true;
+                        console.log('✅ [API Key Validation] Step 2a: API key ID found in cache (CACHE HIT)', {
+                            apiKeyId,
+                            lookupKey
+                        });
+                        this.logger.info('[API Key Validation] Step 2a: API key ID found in cache (CACHE HIT)', {
+                            apiKeyId,
+                            lookupKey
+                        });
+                        // Get hash data from apikey:${id}
+                        const hashKey = `apikey:${apiKeyId}`;
+                        console.log('[API Key Validation] Step 2b: Retrieving API key hash data from cache');
+                        this.logger.info('[API Key Validation] Step 2b: Retrieving API key hash data from cache', {
+                            hashKey
+                        });
+                        try {
+                            const hashData = yield this.redisClient.hGetAll(hashKey);
+                            if (hashData && hashData.id) {
+                                // Parse hash data (matches auth microservice format)
+                                // Parse creator field safely (it's stored as JSON string)
+                                let creator = undefined;
+                                if (hashData.creator) {
+                                    try {
+                                        creator = JSON.parse(hashData.creator);
+                                    }
+                                    catch (parseError) {
+                                        // Ignore parse errors for creator field
+                                        console.warn('[API Key Validation] Failed to parse creator field', {
+                                            error: parseError instanceof Error ? parseError.message : 'Unknown error'
+                                        });
+                                    }
+                                }
+                                key = {
+                                    id: parseInt(hashData.id),
+                                    key: hashData.full_key || hashData.key || apiKey, // Use full_key if available (matches auth microservice behavior)
+                                    microservice: hashData.microservice || '',
+                                    description: hashData.description || undefined,
+                                    is_active: hashData.is_active === 'true', // Stored as 'true'/'false' string
+                                    last_used_at: hashData.last_used_at ? new Date(hashData.last_used_at) : undefined,
+                                    expires_at: hashData.expires_at ? new Date(hashData.expires_at) : undefined,
+                                    created_at: hashData.created_at ? new Date(hashData.created_at) : new Date(),
+                                    updated_at: hashData.updated_at ? new Date(hashData.updated_at) : new Date(),
+                                    created_by: hashData.created_by ? parseInt(hashData.created_by) : undefined,
+                                    creator: creator
+                                };
+                                console.log('✅ [API Key Validation] Step 2c: Successfully retrieved cached API key', {
+                                    apiKeyId: key.id,
+                                    microservice: key.microservice,
+                                    isActive: key.is_active,
+                                    expiresAt: key.expires_at || 'Never',
+                                    expiresAtFormatted: key.expires_at ? new Date(key.expires_at).toISOString() : 'N/A'
+                                });
+                                this.logger.info('[API Key Validation] Step 2c: Successfully retrieved cached API key', {
+                                    apiKeyId: key.id,
+                                    microservice: key.microservice,
+                                    isActive: key.is_active,
+                                    expiresAt: key.expires_at
+                                });
+                            }
+                            else {
+                                console.warn('⚠️ [API Key Validation] Step 2c: API key hash data not found', {
+                                    hashKey,
+                                    apiKeyId
+                                });
+                                this.logger.warn('[API Key Validation] Step 2c: API key hash data not found', {
+                                    hashKey,
+                                    apiKeyId
+                                });
+                            }
+                        }
+                        catch (hashError) {
+                            console.error('❌ [API Key Validation] Step 2c: Failed to retrieve API key hash data', {
+                                error: hashError instanceof Error ? hashError.message : 'Unknown error',
+                                errorStack: hashError instanceof Error ? hashError.stack : undefined,
+                                hashKey
+                            });
+                            this.logger.warn('[API Key Validation] Step 2c: Failed to retrieve API key hash data', {
+                                error: hashError instanceof Error ? hashError.message : 'Unknown error',
+                                hashKey
+                            });
+                        }
                     }
-                    catch (parseError) {
-                        this.logger.warn('Failed to parse cached API key', {
-                            error: parseError instanceof Error ? parseError.message : 'Unknown error'
+                    else {
+                        console.warn('⚠️ [API Key Validation] Step 2a: Invalid API key ID in cache', {
+                            apiKeyIdStr,
+                            lookupKey
+                        });
+                        this.logger.warn('[API Key Validation] Step 2a: Invalid API key ID in cache', {
+                            apiKeyIdStr,
+                            lookupKey
                         });
                     }
                 }
-                // If not in cache, fetch from auth service
-                if (!key) {
-                    let authHost = process.env.AUTH_HOST || 'localhost:3000';
-                    if (!authHost.includes(':')) {
-                        authHost = `${authHost}:3000`;
-                    }
-                    const response = yield fetch(`http://${authHost}/api/v1/api-key/validate`, {
-                        method: 'POST',
-                        headers: { 'Content-Type': 'application/json' },
-                        body: JSON.stringify({ apiKey })
+                else {
+                    cacheHit = false;
+                    console.log('⚠️ [API Key Validation] Step 2a: API key NOT found in cache (CACHE MISS)');
+                    this.logger.info('[API Key Validation] Step 2a: API key not found in cache (CACHE MISS)', {
+                        lookupKey
                     });
-                    if (!response.ok) {
-                        if (response.status === 404 || response.status === 401) {
-                            return null;
-                        }
-                        this.logger.warn('Failed to validate API key from auth service', {
-                            status: response.status
-                        });
-                        return null;
-                    }
-                    const result = yield response.json();
-                    key = result.data || result;
-                    // Cache the result if found (15 minutes TTL for API keys)
-                    if (key && this.safeRedisSet) {
-                        yield this.safeRedisSet(cacheKey, JSON.stringify(key));
-                        this.logger.debug('API key cached', { apiKeyId: key.id });
-                    }
                 }
+                // Step 3: Validate key exists (cache-only, no auth service fallback)
                 if (!key) {
+                    console.error('❌ [API Key Validation] Step 3: API key not found in cache', {
+                        cacheChecked: true,
+                        cacheHit,
+                        apiKeyPreview,
+                        lookupKey
+                    });
+                    this.logger.warn('[API Key Validation] Step 3: API key not found in cache', {
+                        cacheChecked: true,
+                        cacheHit,
+                        lookupKey
+                    });
                     return null;
                 }
-                // Check if key is active
+                console.log('✅ [API Key Validation] Step 3: API key found, validating status', {
+                    apiKeyId: key.id,
+                    microservice: key.microservice,
+                    cacheHit,
+                    expiresAt: key.expires_at || 'Never',
+                    expiresAtFormatted: key.expires_at ? new Date(key.expires_at).toISOString() : 'N/A'
+                });
+                this.logger.info('[API Key Validation] Step 3: API key found, validating status', {
+                    apiKeyId: key.id,
+                    microservice: key.microservice,
+                    cacheHit
+                });
+                // Step 4: Check if key is active
+                console.log('[API Key Validation] Step 4: Checking if API key is active', {
+                    apiKeyId: key.id,
+                    isActive: key.is_active
+                });
+                this.logger.info('[API Key Validation] Step 4: Checking if API key is active', {
+                    apiKeyId: key.id,
+                    isActive: key.is_active
+                });
                 if (!key.is_active) {
-                    this.logger.warn('Inactive API key used', { apiKeyId: key.id });
+                    console.error('❌ [API Key Validation] Step 4a: API key is INACTIVE', {
+                        apiKeyId: key.id,
+                        microservice: key.microservice,
+                        cacheHit
+                    });
+                    this.logger.warn('[API Key Validation] Step 4a: API key is inactive', {
+                        apiKeyId: key.id
+                    });
                     return null;
                 }
-                // Check if key has expired
-                if (key.expires_at && new Date(key.expires_at) < new Date()) {
-                    this.logger.warn('Expired API key used', { apiKeyId: key.id });
-                    return null;
+                console.log('✅ [API Key Validation] Step 4a: API key is active ✓');
+                // Step 5: Check if key has expired
+                if (key.expires_at) {
+                    const expiresAt = new Date(key.expires_at);
+                    const now = new Date();
+                    const isExpired = expiresAt < now;
+                    const timeUntilExpiry = expiresAt.getTime() - now.getTime();
+                    const daysUntilExpiry = Math.floor(timeUntilExpiry / (1000 * 60 * 60 * 24));
+                    console.log('[API Key Validation] Step 5: Checking API key expiration', {
+                        apiKeyId: key.id,
+                        expiresAt: key.expires_at,
+                        expiresAtFormatted: expiresAt.toISOString(),
+                        currentTime: now.toISOString(),
+                        isExpired,
+                        daysUntilExpiry: isExpired ? 'EXPIRED' : daysUntilExpiry
+                    });
+                    this.logger.info('[API Key Validation] Step 5: Checking API key expiration', {
+                        apiKeyId: key.id,
+                        expiresAt: key.expires_at,
+                        currentTime: new Date().toISOString(),
+                        isExpired
+                    });
+                    if (isExpired) {
+                        console.error('❌ [API Key Validation] Step 5a: API key has EXPIRED', {
+                            apiKeyId: key.id,
+                            expiresAt: expiresAt.toISOString(),
+                            expiredAt: expiresAt.toISOString(),
+                            currentTime: now.toISOString(),
+                            daysExpired: Math.abs(daysUntilExpiry)
+                        });
+                        this.logger.warn('[API Key Validation] Step 5a: API key has expired', {
+                            apiKeyId: key.id,
+                            expiresAt: key.expires_at,
+                            currentTime: now.toISOString()
+                        });
+                        return null;
+                    }
+                    console.log('✅ [API Key Validation] Step 5a: API key has not expired ✓', {
+                        daysUntilExpiry,
+                        expiresAtFormatted: expiresAt.toISOString()
+                    });
+                }
+                else {
+                    console.log('ℹ️ [API Key Validation] Step 5: API key has no expiration date (permanent)');
+                    this.logger.info('[API Key Validation] Step 5: API key has no expiration date (permanent)');
                 }
+                console.log('✅ [API Key Validation] Step 6: API key validation SUCCESSFUL', {
+                    apiKeyId: key.id,
+                    microservice: key.microservice,
+                    isActive: key.is_active,
+                    expiresAt: key.expires_at || 'Never',
+                    expiresAtFormatted: key.expires_at ? new Date(key.expires_at).toISOString() : 'N/A',
+                    cacheHit,
+                    timestamp: new Date().toISOString()
+                });
+                this.logger.info('[API Key Validation] Step 6: API key validation successful', {
+                    apiKeyId: key.id,
+                    microservice: key.microservice,
+                    isActive: key.is_active,
+                    expiresAt: key.expires_at || 'Never',
+                    cacheHit
+                });
                 return key;
             }
             catch (error) {
-                this.logger.error('Error validating API key', {
-                    error: error instanceof Error ? error.message : 'Unknown error'
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                const errorStack = error instanceof Error ? error.stack : undefined;
+                const errorName = error instanceof Error ? error.name : 'Unknown';
+                console.error('❌ [API Key Validation] ERROR during validation', {
+                    step: 'Unknown',
+                    error: errorMessage,
+                    errorName,
+                    errorStack,
+                    apiKeyPreview,
+                    timestamp: new Date().toISOString()
+                });
+                this.logger.error('[API Key Validation] Error during validation', {
+                    step: 'Unknown',
+                    error: errorMessage,
+                    errorStack,
+                    errorName,
+                    apiKeyPreview
                 });
                 return null;
             }

package/dist/services/auditService.d.ts

@@ -21,7 +21,15 @@ export declare enum AuditEventType {
     ARREST_OB_GENERATED = "arrest_ob_generated",
     ENDPOINT_ACCESSED = "endpoint_accessed",
     UNAUTHORIZED_ACCESS = "unauthorized_access",
-    FORBIDDEN_ACCESS = "forbidden_access"
+    FORBIDDEN_ACCESS = "forbidden_access",
+    IPRS_PERSON_SEARCHED = "iprs_person_searched",
+    IPRS_PERSON_FETCHED_FROM_VPS = "iprs_person_fetched_from_vps",
+    IPRS_PERSON_STORED = "iprs_person_stored",
+    IPRS_PERSON_UPDATED = "iprs_person_updated",
+    VEHICLE_SEARCHED = "vehicle_searched",
+    VEHICLE_FETCHED_FROM_IPRS = "vehicle_fetched_from_iprs",
+    VEHICLE_STORED = "vehicle_stored",
+    VEHICLE_UPDATED = "vehicle_updated"
 }
 export interface AuditEventPayload {
     timestamp: string;
@@ -36,7 +44,7 @@ export interface AuditEventPayload {
     ip_address?: string;
     user_agent?: string;
     user_id?: number;
-    user_type?: 'officer' | 'device' | 'both' | 'api_key' | 'microservice';
+    user_type?: 'officer' | 'device' | 'both' | 'api_key' | 'microservice' | 'api_key_and_officer';
     officer_id?: number;
     officer_name?: string;
     officer_service_number?: string;
@@ -44,7 +52,11 @@ export interface AuditEventPayload {
     device_id?: number;
     device_device_id?: string;
     api_key_id?: number;
+    api_key_name?: string;
+    api_key_description?: string;
+    api_key_preview?: string;
     authenticated_microservice?: string;
+    source_microservice?: string;
     arrest_id?: number;
     ob_number?: string;
     sync_id?: any;