@govish/shared-services 1.0.0

package/dist/services/penalCodeCacheService.js

@@ -0,0 +1,109 @@
+"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.PenalCodeCacheService = void 0;
+class PenalCodeCacheService {
+    constructor(deps) {
+        this.redisClient = deps.redisClient;
+        this.logger = deps.logger;
+    }
+    /**
+     * Get penal codes from Redis cache
+     * @returns Array of penal codes or null if not found/error
+     */
+    getPenalCodes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Check if Redis is connected
+                if (!this.redisClient.isOpen) {
+                    this.logger.warn('Redis client not connected, attempting to connect...');
+                    yield this.redisClient.connect();
+                }
+                const penalCodesData = yield this.redisClient.get('penalCodes');
+                if (!penalCodesData) {
+                    this.logger.info('Penal codes not found in cache');
+                    return null;
+                }
+                // Parse JSON if the data is a string
+                if (typeof penalCodesData === 'string') {
+                    try {
+                        return JSON.parse(penalCodesData);
+                    }
+                    catch (parseError) {
+                        this.logger.error('Error parsing penal codes from cache', {
+                            error: parseError instanceof Error ? parseError.message : String(parseError)
+                        });
+                        return null;
+                    }
+                }
+                // If it's already an object/array, return as-is
+                return penalCodesData;
+            }
+            catch (error) {
+                this.logger.error('Error getting penal codes from cache', {
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                });
+                return null;
+            }
+        });
+    }
+    /**
+     * Store penal codes in Redis cache
+     * @param penalCodes - Array of penal codes to store
+     */
+    storePenalCodes(penalCodes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Check if Redis is connected
+                if (!this.redisClient.isOpen) {
+                    this.logger.warn('Redis client not connected, attempting to connect...');
+                    yield this.redisClient.connect();
+                }
+                const penalCodesJson = JSON.stringify(penalCodes);
+                yield this.redisClient.set('penalCodes', penalCodesJson);
+                this.logger.info('Penal codes stored in cache successfully', {
+                    count: penalCodes.length
+                });
+            }
+            catch (error) {
+                this.logger.error('Error storing penal codes in cache', {
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                });
+                throw error;
+            }
+        });
+    }
+    /**
+     * Clear penal codes from cache
+     */
+    clearCache() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Check if Redis is connected
+                if (!this.redisClient.isOpen) {
+                    this.logger.warn('Redis client not connected, attempting to connect...');
+                    yield this.redisClient.connect();
+                }
+                yield this.redisClient.del('penalCodes');
+                this.logger.info('Penal codes cache cleared successfully');
+            }
+            catch (error) {
+                this.logger.error('Error clearing penal codes cache', {
+                    error: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined
+                });
+            }
+        });
+    }
+}
+exports.PenalCodeCacheService = PenalCodeCacheService;

package/dist/types/dependencies.d.ts

@@ -0,0 +1,23 @@
+import { Logger } from 'winston';
+import { Producer } from 'kafkajs';
+export interface SharedServicesDependencies {
+    redisClient: any;
+    logger: Logger;
+    authHost?: string;
+    authPort?: string;
+    serverName?: string;
+    auditTopic?: string;
+    jwtConfig?: {
+        secret: string;
+        expiresIn?: number;
+        issuer?: string;
+        audience?: string;
+    };
+    kafkaProducer?: Producer;
+    isProducerConnected?: () => boolean;
+    kafkaBrokers?: string | string[];
+    kafkaClientId?: string;
+    enableDebugLogs?: boolean;
+    safeRedisGet?: (key: string) => Promise<string | null>;
+    safeRedisSet?: (key: string, value: string) => Promise<boolean>;
+}

package/dist/types/dependencies.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/logMode.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Environment mode utilities
+ * Controls whether logs and debug information should be shown
+ */
+export type EnvironmentMode = 'development' | 'production' | 'test';
+/**
+ * Get the current environment mode
+ */
+export declare const getEnvironmentMode: () => EnvironmentMode;
+/**
+ * Check if we're in development mode
+ */
+export declare const isDevelopmentMode: () => boolean;
+/**
+ * Check if we're in production mode
+ */
+export declare const isProductionMode: () => boolean;
+/**
+ * Conditional console.log - only logs in development mode
+ */
+export declare const devLog: (...args: any[]) => void;
+/**
+ * Conditional console.error - always logs errors, but with less detail in production
+ */
+export declare const devError: (...args: any[]) => void;
+/**
+ * Conditional console.warn - always logs warnings (even in production)
+ */
+export declare const devWarn: (...args: any[]) => void;
+/**
+ * Conditional console.debug - only logs in development mode
+ */
+export declare const devDebug: (...args: any[]) => void;

package/dist/utils/logMode.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Environment mode utilities
+ * Controls whether logs and debug information should be shown
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devDebug = exports.devWarn = exports.devError = exports.devLog = exports.isProductionMode = exports.isDevelopmentMode = exports.getEnvironmentMode = void 0;
+/**
+ * Get the current environment mode
+ */
+const getEnvironmentMode = () => {
+    const env = process.env.NODE_ENV || 'development';
+    if (env === 'production' || env === 'prod') {
+        return 'production';
+    }
+    if (env === 'test') {
+        return 'test';
+    }
+    return 'development';
+};
+exports.getEnvironmentMode = getEnvironmentMode;
+/**
+ * Check if we're in development mode
+ */
+const isDevelopmentMode = () => {
+    return (0, exports.getEnvironmentMode)() === 'development';
+};
+exports.isDevelopmentMode = isDevelopmentMode;
+/**
+ * Check if we're in production mode
+ */
+const isProductionMode = () => {
+    return (0, exports.getEnvironmentMode)() === 'production';
+};
+exports.isProductionMode = isProductionMode;
+/**
+ * Conditional console.log - only logs in development mode
+ */
+const devLog = (...args) => {
+    if ((0, exports.isDevelopmentMode)()) {
+        console.log(...args);
+    }
+};
+exports.devLog = devLog;
+/**
+ * Conditional console.error - always logs errors, but with less detail in production
+ */
+const devError = (...args) => {
+    if ((0, exports.isDevelopmentMode)()) {
+        console.error(...args);
+    }
+    else {
+        // In production, only log minimal error info
+        const errorInfo = args.map(arg => {
+            if (arg instanceof Error) {
+                return arg.message;
+            }
+            if (typeof arg === 'object') {
+                // Only include essential error info in production
+                return JSON.stringify(Object.assign({ error: arg.error || arg.message || 'Unknown error' }, ((0, exports.isDevelopmentMode)() ? arg : {})));
+            }
+            return arg;
+        });
+        console.error(...errorInfo);
+    }
+};
+exports.devError = devError;
+/**
+ * Conditional console.warn - always logs warnings (even in production)
+ */
+const devWarn = (...args) => {
+    // Always log warnings
+    if ((0, exports.isDevelopmentMode)()) {
+        console.warn(...args);
+    }
+    else {
+        // In production, still show warnings
+        console.warn('[WARN]', ...args);
+    }
+};
+exports.devWarn = devWarn;
+/**
+ * Conditional console.debug - only logs in development mode
+ */
+const devDebug = (...args) => {
+    if ((0, exports.isDevelopmentMode)()) {
+        console.debug(...args);
+    }
+};
+exports.devDebug = devDebug;

package/dist/utils/redis.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Helper function to safely get from Redis with reconnection handling
+ * @param redisClient - Redis client instance
+ * @param key - Redis key to get
+ * @returns The value from Redis or null if not found/error
+ */
+export declare const createSafeRedisGet: (redisClient: any) => (key: string) => Promise<string | null>;
+/**
+ * Helper function to safely set in Redis with reconnection handling
+ * @param redisClient - Redis client instance
+ * @param key - Redis key to set
+ * @param value - Value to set
+ * @returns true if successful, false otherwise
+ */
+export declare const createSafeRedisSet: (redisClient: any) => (key: string, value: string) => Promise<boolean>;
+/**
+ * Factory function to create both safe Redis utility functions
+ * @param redisClient - Redis client instance
+ * @returns Object containing safeRedisGet and safeRedisSet functions
+ */
+export declare const createSafeRedisUtils: (redisClient: any) => {
+    safeRedisGet: (key: string) => Promise<string | null>;
+    safeRedisSet: (key: string, value: string) => Promise<boolean>;
+};

package/dist/utils/redis.js

@@ -0,0 +1,122 @@
+"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.createSafeRedisUtils = exports.createSafeRedisSet = exports.createSafeRedisGet = void 0;
+const logMode_1 = require("./logMode");
+/**
+ * Helper function to ensure Redis client is connected
+ */
+const ensureRedisConnected = (redisClient) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    try {
+        if (!redisClient.isOpen) {
+            (0, logMode_1.devLog)(`[REDIS] Client closed, attempting to reconnect...`);
+            yield redisClient.connect();
+            (0, logMode_1.devLog)(`[REDIS] Successfully reconnected`);
+        }
+        return true;
+    }
+    catch (error) {
+        // If already connected, that's fine
+        if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('already connected')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('Connected'))) {
+            return true;
+        }
+        (0, logMode_1.devError)(`[REDIS] Error connecting:`, error);
+        return false;
+    }
+});
+/**
+ * Helper function to safely get from Redis with reconnection handling
+ * @param redisClient - Redis client instance
+ * @param key - Redis key to get
+ * @returns The value from Redis or null if not found/error
+ */
+const createSafeRedisGet = (redisClient) => {
+    return (key) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            // Ensure client is connected
+            const connected = yield ensureRedisConnected(redisClient);
+            if (!connected) {
+                return null;
+            }
+            return yield redisClient.get(key);
+        }
+        catch (error) {
+            // If error is due to closed client, try to reconnect once
+            if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('closed')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('ClientClosedError'))) {
+                try {
+                    (0, logMode_1.devLog)(`[REDIS] Reconnecting after closed client error for key: ${key}`);
+                    yield ensureRedisConnected(redisClient);
+                    return yield redisClient.get(key);
+                }
+                catch (retryError) {
+                    (0, logMode_1.devError)(`[REDIS] Failed to reconnect for key ${key}:`, retryError);
+                    return null;
+                }
+            }
+            (0, logMode_1.devError)(`[REDIS] Error getting key ${key}:`, error);
+            return null;
+        }
+    });
+};
+exports.createSafeRedisGet = createSafeRedisGet;
+/**
+ * Helper function to safely set in Redis with reconnection handling
+ * @param redisClient - Redis client instance
+ * @param key - Redis key to set
+ * @param value - Value to set
+ * @returns true if successful, false otherwise
+ */
+const createSafeRedisSet = (redisClient) => {
+    return (key, value) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            // Ensure client is connected
+            const connected = yield ensureRedisConnected(redisClient);
+            if (!connected) {
+                return false;
+            }
+            yield redisClient.set(key, value);
+            return true;
+        }
+        catch (error) {
+            // If error is due to closed client, try to reconnect once
+            if (((_a = error === null || error === void 0 ? void 0 : error.message) === null || _a === void 0 ? void 0 : _a.includes('closed')) || ((_b = error === null || error === void 0 ? void 0 : error.message) === null || _b === void 0 ? void 0 : _b.includes('ClientClosedError'))) {
+                try {
+                    (0, logMode_1.devLog)(`[REDIS] Reconnecting after closed client error for key: ${key}`);
+                    yield ensureRedisConnected(redisClient);
+                    yield redisClient.set(key, value);
+                    return true;
+                }
+                catch (retryError) {
+                    (0, logMode_1.devError)(`[REDIS] Failed to reconnect for key ${key}:`, retryError);
+                    return false;
+                }
+            }
+            (0, logMode_1.devError)(`[REDIS] Error setting key ${key}:`, error);
+            return false;
+        }
+    });
+};
+exports.createSafeRedisSet = createSafeRedisSet;
+/**
+ * Factory function to create both safe Redis utility functions
+ * @param redisClient - Redis client instance
+ * @returns Object containing safeRedisGet and safeRedisSet functions
+ */
+const createSafeRedisUtils = (redisClient) => {
+    return {
+        safeRedisGet: (0, exports.createSafeRedisGet)(redisClient),
+        safeRedisSet: (0, exports.createSafeRedisSet)(redisClient),
+    };
+};
+exports.createSafeRedisUtils = createSafeRedisUtils;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@govish/shared-services",
+  "version": "1.0.0",
+  "description": "Govish shared services package - includes cache services, API key service, audit logging, and authentication middleware",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "govish",
+    "shared-services",
+    "redis",
+    "cache",
+    "kafka",
+    "audit",
+    "authentication",
+    "middleware",
+    "typescript"
+  ],
+  "author": "",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "dependencies": {
+    "jsonwebtoken": "^9.0.1",
+    "kafkajs": "^2.2.4",
+    "redis": "^4.7.0",
+    "winston": "^3.19.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/jsonwebtoken": "^9.0.1",
+    "@types/node": "^20.11.26",
+    "typescript": "^5.6.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}