@govish/shared-services 1.0.0

package/dist/services/deviceCacheService.d.ts

@@ -0,0 +1,46 @@
+import { SharedServicesDependencies } from '../types/dependencies';
+export declare class DeviceCacheService {
+    private redisClient;
+    private logger;
+    constructor(deps: SharedServicesDependencies);
+    /**
+     * Store individual device as hash with indexes
+     */
+    storeDevice(device: any): Promise<void>;
+    /**
+     * Get device by ID - O(1) lookup
+     */
+    getDeviceById(id: number): Promise<any | null>;
+    /**
+     * Get device by device_id
+     */
+    getDeviceByDeviceId(device_id: string): Promise<any | null>;
+    /**
+     * Get device by serial number
+     */
+    getDeviceBySerialNumber(serial_number: string): Promise<any | null>;
+    /**
+     * Get multiple devices efficiently using pipeline
+     */
+    getDevicesByIds(ids: number[]): Promise<any[]>;
+    /**
+     * Query by police station
+     */
+    getDevicesByStation(stationId: number): Promise<any[]>;
+    /**
+     * Get active devices
+     */
+    getActiveDevices(): Promise<any[]>;
+    /**
+     * Get all devices from cache
+     */
+    getAllDevices(): Promise<any[]>;
+    /**
+     * Clear all device cache
+     */
+    clearCache(): Promise<void>;
+    /**
+     * Remove single device from cache
+     */
+    removeDevice(id: number): Promise<void>;
+}

package/dist/services/deviceCacheService.js

@@ -0,0 +1,432 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceCacheService = void 0;
+class DeviceCacheService {
+    constructor(deps) {
+        this.redisClient = deps.redisClient;
+        this.logger = deps.logger;
+    }
+    /**
+     * Store individual device as hash with indexes
+     */
+    storeDevice(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                if (!device || !device.id) {
+                    throw new Error('Invalid device: missing id');
+                }
+                // Check if Redis is connected
+                if (!this.redisClient.isOpen) {
+                    this.logger.warn('Redis client not connected, attempting to connect...');
+                    yield this.redisClient.connect();
+                }
+                const key = `device:${device.id}`;
+                // Check if key exists and delete it if it's the wrong type (from old cache implementation)
+                try {
+                    const keyType = yield this.redisClient.type(key);
+                    if (keyType !== 'hash' && keyType !== 'none') {
+                        this.logger.warn(`Deleting key ${key} with wrong type: ${keyType}`);
+                        yield this.redisClient.del(key);
+                    }
+                }
+                catch (typeError) {
+                    // If type check fails, try to delete the key anyway
+                    this.logger.warn(`Error checking key type for ${key}, attempting to delete`, {
+                        error: typeError instanceof Error ? typeError.message : String(typeError)
+                    });
+                    try {
+                        yield this.redisClient.del(key);
+                    }
+                    catch (delError) {
+                        // Ignore delete errors, continue with store
+                    }
+                }
+                // Helper function to safely convert dates
+                const safeDateToString = (date) => {
+                    if (!date)
+                        return '';
+                    if (date instanceof Date) {
+                        return isNaN(date.getTime()) ? '' : date.toISOString();
+                    }
+                    if (typeof date === 'string') {
+                        return date;
+                    }
+                    return '';
+                };
+                // Prepare hash data - ensure all values are strings
+                const hashData = {
+                    id: device.id.toString(),
+                    device_id: (device.device_id || '').toString(),
+                    device_name: (device.device_name || '').toString(),
+                    device_type: (device.device_type || '').toString(),
+                    serial_number: (device.serial_number || '').toString(),
+                    imei: (device.imei || '').toString(),
+                    is_active: (((_a = device.is_active) === null || _a === void 0 ? void 0 : _a.toString()) || 'false').toString(),
+                    policeStationId: (((_b = device.policeStationId) === null || _b === void 0 ? void 0 : _b.toString()) || '').toString(),
+                    created_at: safeDateToString(device.created_at),
+                    updated_at: safeDateToString(device.updated_at),
+                };
+                // Stringify nested objects safely
+                try {
+                    hashData.policeStation = JSON.stringify(device.policeStation || null);
+                }
+                catch (jsonError) {
+                    this.logger.warn('Failed to stringify policeStation', { deviceId: device.id });
+                    hashData.policeStation = 'null';
+                }
+                // Store as hash with JSON-stringified complex fields
+                yield this.redisClient.hSet(key, hashData);
+                // Create indexes for common queries
+                // Helper to safely add to set (delete if wrong type first)
+                const safeSAdd = (setKey, value) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const keyType = yield this.redisClient.type(setKey);
+                        if (keyType !== 'set' && keyType !== 'none') {
+                            yield this.redisClient.del(setKey);
+                        }
+                        yield this.redisClient.sAdd(setKey, value);
+                    }
+                    catch (error) {
+                        // If it fails, try to delete and retry
+                        try {
+                            yield this.redisClient.del(setKey);
+                            yield this.redisClient.sAdd(setKey, value);
+                        }
+                        catch (retryError) {
+                            this.logger.warn(`Failed to add to set ${setKey}`, {
+                                error: retryError instanceof Error ? retryError.message : String(retryError)
+                            });
+                        }
+                    }
+                });
+                // Helper to safely set string value (delete if wrong type first)
+                const safeSet = (key, value) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const keyType = yield this.redisClient.type(key);
+                        if (keyType !== 'string' && keyType !== 'none') {
+                            yield this.redisClient.del(key);
+                        }
+                        yield this.redisClient.set(key, value);
+                    }
+                    catch (error) {
+                        // If it fails, try to delete and retry
+                        try {
+                            yield this.redisClient.del(key);
+                            yield this.redisClient.set(key, value);
+                        }
+                        catch (retryError) {
+                            this.logger.warn(`Failed to set key ${key}`, {
+                                error: retryError instanceof Error ? retryError.message : String(retryError)
+                            });
+                        }
+                    }
+                });
+                if (device.policeStationId) {
+                    yield safeSAdd(`devices:station:${device.policeStationId}`, device.id.toString());
+                }
+                if (device.device_id) {
+                    yield safeSet(`device:by_device_id:${device.device_id}`, device.id.toString());
+                }
+                if (device.serial_number) {
+                    yield safeSet(`device:by_serial:${device.serial_number}`, device.id.toString());
+                }
+                if (device.is_active) {
+                    yield safeSAdd('devices:active', device.id.toString());
+                }
+                else {
+                    yield safeSAdd('devices:inactive', device.id.toString());
+                }
+                // Maintain list of all device IDs
+                yield safeSAdd('devices:all', device.id.toString());
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                const errorStack = error instanceof Error ? error.stack : undefined;
+                const errorDetails = {
+                    error: errorMessage,
+                    errorStack: errorStack,
+                    deviceId: device === null || device === void 0 ? void 0 : device.id,
+                    deviceKeys: device ? Object.keys(device) : [],
+                    device: device ? JSON.stringify(device, (key, value) => {
+                        // Handle circular references and Date objects
+                        if (value instanceof Date) {
+                            return value.toISOString();
+                        }
+                        if (typeof value === 'object' && value !== null) {
+                            try {
+                                return value;
+                            }
+                            catch (e) {
+                                return '[Circular]';
+                            }
+                        }
+                        return value;
+                    }, 2) : 'No device data'
+                };
+                // Log error (logger always logs, console only in dev)
+                this.logger.error('Error storing device in cache', errorDetails);
+                throw error;
+            }
+        });
+    }
+    /**
+     * Get device by ID - O(1) lookup
+     */
+    getDeviceById(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield this.redisClient.hGetAll(`device:${id}`);
+                if (!data || !data.id)
+                    return null;
+                // Parse JSON fields
+                return Object.assign(Object.assign({}, data), { id: parseInt(data.id), policeStationId: data.policeStationId ? parseInt(data.policeStationId) : null, is_active: data.is_active === 'true', created_at: data.created_at ? new Date(data.created_at) : null, updated_at: data.updated_at ? new Date(data.updated_at) : null, policeStation: data.policeStation ? JSON.parse(data.policeStation) : null });
+            }
+            catch (error) {
+                this.logger.error('Error getting device from cache', {
+                    error: error instanceof Error ? error.message : String(error),
+                    deviceId: id
+                });
+                return null;
+            }
+        });
+    }
+    /**
+     * Get device by device_id
+     */
+    getDeviceByDeviceId(device_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const idStr = yield this.redisClient.get(`device:by_device_id:${device_id}`);
+                if (!idStr)
+                    return null;
+                const id = parseInt(String(idStr));
+                return this.getDeviceById(id);
+            }
+            catch (error) {
+                this.logger.error('Error getting device by device_id from cache', {
+                    error: error instanceof Error ? error.message : String(error),
+                    device_id
+                });
+                return null;
+            }
+        });
+    }
+    /**
+     * Get device by serial number
+     */
+    getDeviceBySerialNumber(serial_number) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const idStr = yield this.redisClient.get(`device:by_serial:${serial_number}`);
+                if (!idStr)
+                    return null;
+                const id = parseInt(String(idStr));
+                return this.getDeviceById(id);
+            }
+            catch (error) {
+                this.logger.error('Error getting device by serial from cache', {
+                    error: error instanceof Error ? error.message : String(error),
+                    serial_number
+                });
+                return null;
+            }
+        });
+    }
+    /**
+     * Get multiple devices efficiently using pipeline
+     */
+    getDevicesByIds(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (ids.length === 0)
+                return [];
+            try {
+                const pipeline = this.redisClient.multi();
+                ids.forEach(id => pipeline.hGetAll(`device:${id}`));
+                const results = yield pipeline.exec();
+                return results
+                    .map((result) => {
+                    if (result[0])
+                        return null; // Skip errors
+                    const data = result[1];
+                    if (!data || !data.id)
+                        return null;
+                    return Object.assign(Object.assign({}, data), { id: parseInt(data.id), policeStationId: data.policeStationId ? parseInt(data.policeStationId) : null, is_active: data.is_active === 'true', created_at: data.created_at ? new Date(data.created_at) : null, updated_at: data.updated_at ? new Date(data.updated_at) : null, policeStation: data.policeStation ? JSON.parse(data.policeStation) : null });
+                })
+                    .filter(Boolean);
+            }
+            catch (error) {
+                this.logger.error('Error getting devices from cache', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                return [];
+            }
+        });
+    }
+    /**
+     * Query by police station
+     */
+    getDevicesByStation(stationId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const deviceIds = yield this.redisClient.sMembers(`devices:station:${stationId}`);
+                const ids = Array.isArray(deviceIds)
+                    ? deviceIds.map((id) => parseInt(String(id)))
+                    : [];
+                return this.getDevicesByIds(ids);
+            }
+            catch (error) {
+                this.logger.error('Error getting devices by station from cache', {
+                    error: error instanceof Error ? error.message : String(error),
+                    stationId
+                });
+                return [];
+            }
+        });
+    }
+    /**
+     * Get active devices
+     */
+    getActiveDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const deviceIds = yield this.redisClient.sMembers('devices:active');
+                const ids = Array.isArray(deviceIds)
+                    ? deviceIds.map((id) => parseInt(String(id)))
+                    : [];
+                return this.getDevicesByIds(ids);
+            }
+            catch (error) {
+                this.logger.error('Error getting active devices from cache', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                return [];
+            }
+        });
+    }
+    /**
+     * Get all devices from cache
+     */
+    getAllDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const deviceIds = yield this.redisClient.sMembers('devices:all');
+                const ids = Array.isArray(deviceIds)
+                    ? deviceIds.map((id) => parseInt(String(id)))
+                    : [];
+                const devices = yield this.getDevicesByIds(ids);
+                // Sort by ID descending to match original behavior
+                return devices.sort((a, b) => b.id - a.id);
+            }
+            catch (error) {
+                this.logger.error('Error getting all devices from cache', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+                return [];
+            }
+        });
+    }
+    /**
+     * Clear all device cache
+     */
+    clearCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Delete old cache key if it exists (from previous implementation)
+                try {
+                    yield this.redisClient.del('devices');
+                }
+                catch (e) {
+                    // Ignore if key doesn't exist
+                }
+                const deviceIds = yield this.redisClient.sMembers('devices:all');
+                const ids = Array.isArray(deviceIds) ? deviceIds : [];
+                if (ids.length > 0) {
+                    const pipeline = this.redisClient.multi();
+                    ids.forEach((id) => {
+                        const idStr = String(id);
+                        pipeline.del(`device:${idStr}`);
+                    });
+                    yield pipeline.exec();
+                }
+                // Clear indexes
+                const keys = yield this.redisClient.keys('devices:*');
+                if (keys.length > 0) {
+                    yield this.redisClient.del(keys);
+                }
+                // Clear lookup keys
+                const lookupKeys = yield this.redisClient.keys('device:by_*');
+                if (lookupKeys.length > 0) {
+                    yield this.redisClient.del(lookupKeys);
+                }
+                // Clear individual device hash keys (in case they exist from previous attempts)
+                const deviceKeys = yield this.redisClient.keys('device:[0-9]*');
+                const keysArray = Array.isArray(deviceKeys) ? deviceKeys : [];
+                if (keysArray.length > 0) {
+                    // Filter to only get device:ID pattern (not device:by_*)
+                    const hashKeys = keysArray
+                        .map((key) => typeof key === 'string' ? key : key.toString())
+                        .filter((key) => /^device:\d+$/.test(key));
+                    if (hashKeys.length > 0) {
+                        yield this.redisClient.del(hashKeys);
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error('Error clearing device cache', {
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+        });
+    }
+    /**
+     * Remove single device from cache
+     */
+    removeDevice(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const device = yield this.getDeviceById(id);
+                if (device) {
+                    // Remove from indexes
+                    if (device.policeStationId) {
+                        yield this.redisClient.sRem(`devices:station:${device.policeStationId}`, id.toString());
+                    }
+                    if (device.device_id) {
+                        const deviceIdStr = typeof device.device_id === 'string' ? device.device_id : device.device_id.toString();
+                        yield this.redisClient.del(`device:by_device_id:${deviceIdStr}`);
+                    }
+                    if (device.serial_number) {
+                        const serialStr = typeof device.serial_number === 'string' ? device.serial_number : device.serial_number.toString();
+                        yield this.redisClient.del(`device:by_serial:${serialStr}`);
+                    }
+                    if (device.is_active) {
+                        yield this.redisClient.sRem('devices:active', id.toString());
+                    }
+                    else {
+                        yield this.redisClient.sRem('devices:inactive', id.toString());
+                    }
+                    // Remove from all list
+                    yield this.redisClient.sRem('devices:all', id.toString());
+                    // Remove hash
+                    yield this.redisClient.del(`device:${id}`);
+                }
+            }
+            catch (error) {
+                this.logger.error('Error removing device from cache', {
+                    error: error instanceof Error ? error.message : String(error),
+                    deviceId: id
+                });
+            }
+        });
+    }
+}
+exports.DeviceCacheService = DeviceCacheService;

package/dist/services/deviceService.d.ts

@@ -0,0 +1,21 @@
+import { SharedServicesDependencies } from '../types/dependencies';
+/**
+ * Device Service - Handles device retrieval with cache and auth service fallback
+ *
+ * This service:
+ * 1. First tries Redis cache (via DeviceCacheService)
+ * 2. Falls back to auth service API if cache miss
+ * 3. Stores fetched device in cache for future use
+ */
+export declare class DeviceService {
+    private deviceCacheService;
+    private logger;
+    private authHost?;
+    private authPort?;
+    constructor(deps: SharedServicesDependencies);
+    /**
+     * Get device by ID from Redis cache, fallback to auth service
+     * First tries Redis cache, then falls back to auth service API
+     */
+    getDeviceById(deviceId: string | number): Promise<any | null>;
+}

package/dist/services/deviceService.js

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceService = void 0;
+const deviceCacheService_1 = require("./deviceCacheService");
+/**
+ * Device Service - Handles device retrieval with cache and auth service fallback
+ *
+ * This service:
+ * 1. First tries Redis cache (via DeviceCacheService)
+ * 2. Falls back to auth service API if cache miss
+ * 3. Stores fetched device in cache for future use
+ */
+class DeviceService {
+    constructor(deps) {
+        this.deviceCacheService = new deviceCacheService_1.DeviceCacheService(deps);
+        this.logger = deps.logger;
+        this.authHost = deps.authHost || process.env.AUTH_HOST;
+        this.authPort = deps.authPort || process.env.AUTH_PORT;
+    }
+    /**
+     * Get device by ID from Redis cache, fallback to auth service
+     * First tries Redis cache, then falls back to auth service API
+     */
+    getDeviceById(deviceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const deviceIdNum = typeof deviceId === 'string' ? parseInt(deviceId) : deviceId;
+                if (isNaN(deviceIdNum)) {
+                    this.logger.warn('Invalid device ID', { deviceId });
+                    return null;
+                }
+                // Try cache first
+                try {
+                    const cachedDevice = yield this.deviceCacheService.getDeviceById(deviceIdNum);
+                    if (cachedDevice) {
+                        this.logger.debug(`Device ${deviceIdNum} retrieved from Redis cache`);
+                        return cachedDevice;
+                    }
+                }
+                catch (cacheError) {
+                    this.logger.warn('Cache read error, falling back to auth service', {
+                        error: cacheError instanceof Error ? cacheError.message : String(cacheError),
+                        deviceId: deviceIdNum
+                    });
+                }
+                // Fallback to auth service if host is configured
+                if (!this.authHost) {
+                    this.logger.warn('Auth host not configured, cannot fetch device from auth service', {
+                        deviceId: deviceIdNum
+                    });
+                    return null;
+                }
+                const authUrl = this.authPort
+                    ? `http://${this.authHost}:${this.authPort}/api/v1/device/cache/${deviceIdNum}`
+                    : `http://${this.authHost}/api/v1/device/cache/${deviceIdNum}`;
+                this.logger.debug(`Cache miss for device ${deviceIdNum}, fetching from auth service`);
+                const response = yield fetch(authUrl);
+                if (!response.ok) {
+                    if (response.status === 404) {
+                        this.logger.warn(`Device ${deviceIdNum} not found in auth service`);
+                        return null;
+                    }
+                    throw new Error(`Failed to fetch device: ${response.status} ${response.statusText}`);
+                }
+                const result = yield response.json();
+                const device = result.data || result;
+                // Store in cache for future use
+                if (device && device.id) {
+                    try {
+                        yield this.deviceCacheService.storeDevice(device);
+                        this.logger.debug(`Device ${deviceIdNum} stored in cache after fetch from auth service`);
+                    }
+                    catch (cacheStoreError) {
+                        // Don't fail if cache store fails, just log
+                        this.logger.warn('Failed to store device in cache after fetch', {
+                            error: cacheStoreError instanceof Error ? cacheStoreError.message : String(cacheStoreError),
+                            deviceId: deviceIdNum
+                        });
+                    }
+                }
+                this.logger.debug(`Device ${deviceIdNum} fetched from auth service`);
+                return device;
+            }
+            catch (error) {
+                this.logger.error('Error fetching device by ID', {
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                    deviceId: deviceId.toString()
+                });
+                return null;
+            }
+        });
+    }
+}
+exports.DeviceService = DeviceService;

package/dist/services/officerCacheService.d.ts

@@ -0,0 +1,50 @@
+import { SharedServicesDependencies } from '../types/dependencies';
+export declare class OfficerCacheService {
+    private redisClient;
+    private logger;
+    constructor(deps: SharedServicesDependencies);
+    /**
+     * Store individual officer as hash with indexes
+     */
+    storeOfficer(officer: any): Promise<void>;
+    /**
+     * Get officer by ID - O(1) lookup
+     */
+    getOfficerById(id: number): Promise<any | null>;
+    /**
+     * Get multiple officers efficiently using pipeline
+     */
+    getOfficersByIds(ids: number[]): Promise<any[]>;
+    /**
+     * Query by station
+     */
+    getOfficersByStation(stationId: number): Promise<any[]>;
+    /**
+     * Query by rank
+     */
+    getOfficersByRank(rankId: number): Promise<any[]>;
+    /**
+     * Query by role
+     */
+    getOfficersByRole(roleId: number): Promise<any[]>;
+    /**
+     * Get all officers from cache
+     */
+    getAllOfficers(): Promise<any[]>;
+    /**
+     * Get officer by service_number
+     */
+    getOfficerByServiceNumber(service_number: string): Promise<any | null>;
+    /**
+     * Cache all officers from auth service
+     */
+    cacheAllOfficers(): Promise<any[]>;
+    /**
+     * Clear all officer cache
+     */
+    clearCache(): Promise<void>;
+    /**
+     * Remove single officer from cache
+     */
+    removeOfficer(id: number): Promise<void>;
+}