@goniglep57/node 1.0.1 → 1.0.3

package/awsSecrets.js

@@ -0,0 +1,162 @@
+/**
+ * AWS Secrets Manager utility for fetching secrets at runtime.
+ * 
+ * This module provides a centralized way to fetch secrets from AWS Secrets Manager,
+ * eliminating the need to manually set secrets via Heroku config vars.
+ * 
+ * Usage:
+ *   const { awsSecrets } = require('@goniglep57/node')
+ *   
+ *   // At app startup:
+ *   await awsSecrets.init()
+ *   
+ *   // Then use secrets:
+ *   const apiKey = awsSecrets.get('INTERNAL_API_KEY')
+ * 
+ * Required environment variables:
+ *   - AWS_ACCESS_KEY_ID_SECRETS (or AWS_ACCESS_KEY_ID)
+ *   - AWS_SECRET_ACCESS_KEY_SECRETS (or AWS_SECRET_ACCESS_KEY)
+ *   - AWS_REGION (optional, defaults to 'us-east-1')
+ */
+
+const { SecretsManagerClient, GetSecretValueCommand } = require('@aws-sdk/client-secrets-manager')
+
+// Cache for secrets (keyed by secret name)
+const secretsCache = {}
+
+// Default secret name for internal API keys
+const DEFAULT_SECRET_NAME = 'prod/internal'
+
+/**
+ * Get AWS credentials from environment variables.
+ * Supports both dedicated secrets credentials and fallback to general AWS credentials.
+ */
+const getCredentials = () => {
+    const accessKeyId = process.env.AWS_ACCESS_KEY_ID_SECRETS || process.env.AWS_ACCESS_KEY_ID
+    const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY_SECRETS || process.env.AWS_SECRET_ACCESS_KEY
+    
+    if (!accessKeyId || !secretAccessKey) {
+        throw new Error(
+            'AWS credentials not configured. Set AWS_ACCESS_KEY_ID_SECRETS and AWS_SECRET_ACCESS_KEY_SECRETS ' +
+            '(or AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY) environment variables.'
+        )
+    }
+    
+    return { accessKeyId, secretAccessKey }
+}
+
+/**
+ * Create a Secrets Manager client with configured credentials.
+ */
+const createClient = () => {
+    const credentials = getCredentials()
+    const region = process.env.AWS_REGION || 'us-east-1'
+    
+    return new SecretsManagerClient({ region, credentials })
+}
+
+/**
+ * Fetch a secret from AWS Secrets Manager.
+ * Results are cached to avoid repeated API calls.
+ * 
+ * @param {string} secretName - The name/ARN of the secret in Secrets Manager
+ * @returns {Promise<object>} - The parsed secret value (assumes JSON)
+ */
+const fetchSecret = async (secretName = DEFAULT_SECRET_NAME) => {
+    // Return cached value if available
+    if (secretsCache[secretName]) {
+        return secretsCache[secretName]
+    }
+    
+    const client = createClient()
+    
+    try {
+        const command = new GetSecretValueCommand({ SecretId: secretName })
+        const response = await client.send(command)
+        
+        // Parse the secret (assumes JSON format)
+        const secretValue = JSON.parse(response.SecretString)
+        
+        // Cache the result
+        secretsCache[secretName] = secretValue
+        
+        console.log(`[awsSecrets] Loaded secret: ${secretName}`)
+        return secretValue
+    } catch (error) {
+        console.error(`[awsSecrets] Failed to fetch secret '${secretName}':`, error.message)
+        throw error
+    }
+}
+
+/**
+ * Initialize secrets by fetching the default secret.
+ * Call this at app startup before using any secrets.
+ * 
+ * @param {string|string[]} secretNames - Secret name(s) to fetch (defaults to 'prod/internal')
+ * @returns {Promise<void>}
+ */
+const init = async (secretNames = DEFAULT_SECRET_NAME) => {
+    const names = Array.isArray(secretNames) ? secretNames : [secretNames]
+    
+    for (const name of names) {
+        await fetchSecret(name)
+    }
+    
+    console.log(`[awsSecrets] Initialized with ${names.length} secret(s)`)
+}
+
+/**
+ * Get a specific key from a cached secret.
+ * 
+ * @param {string} key - The key to retrieve from the secret
+ * @param {string} secretName - The secret name (defaults to 'prod/internal')
+ * @returns {string|undefined} - The secret value, or undefined if not found
+ */
+const get = (key, secretName = DEFAULT_SECRET_NAME) => {
+    const secret = secretsCache[secretName]
+    
+    if (!secret) {
+        console.warn(`[awsSecrets] Secret '${secretName}' not loaded. Call init() first.`)
+        return undefined
+    }
+    
+    return secret[key]
+}
+
+/**
+ * Get the entire cached secret object.
+ * 
+ * @param {string} secretName - The secret name (defaults to 'prod/internal')
+ * @returns {object|undefined} - The full secret object, or undefined if not loaded
+ */
+const getAll = (secretName = DEFAULT_SECRET_NAME) => {
+    return secretsCache[secretName]
+}
+
+/**
+ * Clear the secrets cache (useful for testing or forcing refresh).
+ */
+const clearCache = () => {
+    Object.keys(secretsCache).forEach(key => delete secretsCache[key])
+    console.log('[awsSecrets] Cache cleared')
+}
+
+/**
+ * Check if secrets are initialized.
+ * 
+ * @param {string} secretName - The secret name to check (defaults to 'prod/internal')
+ * @returns {boolean}
+ */
+const isInitialized = (secretName = DEFAULT_SECRET_NAME) => {
+    return !!secretsCache[secretName]
+}
+
+module.exports = {
+    init,
+    fetchSecret,
+    get,
+    getAll,
+    clearCache,
+    isInitialized,
+    DEFAULT_SECRET_NAME
+}

package/dropbox.js

@@ -91,9 +91,9 @@ const Dropbox = (httpClient, config={retry:false}) => {
                 console.error('Path not found in dropbox', body)
                 return null
             }
-            // throw err
-            console.error(err.message)
-            // throw err
+            // Log detailed Dropbox API error instead of generic HTTP status
+            console.error('Dropbox API error:', err.response?.data?.error_summary || err.message, body)
+            return null
         }
     }
 

package/index.js

@@ -1,8 +1,8 @@
 //generator:exportdir
 exports.alerts = require('./alerts.js')
+exports.awsSecrets = require('./awsSecrets.js')
 exports.dropbox = require('./dropbox.js')
 exports.ncrypt = require('./ncrypt.js')
 exports.secret = require('./secret.js')
 exports.server = require('./server.js')
-exports.slack = require('./slack.js')
 exports.util = require('./util.js')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goniglep57/node",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "A package full of utility functions",
   "main": "index.js",
   "scripts": {
@@ -10,6 +10,7 @@
   "license": "ISC",
   "dependencies": {
     "@aws-sdk/client-s3": "^3.957.0",
+    "@aws-sdk/client-secrets-manager": "^3.957.0",
     "@aws-sdk/client-sqs": "^3.957.0",
     "nodemailer": "^6.9.16"
   }

package/slack.js

@@ -1,184 +0,0 @@
-/**
- * Slack notification module for error alerting across all services
- * 
- * Usage:
- *   const { slack } = require('@goniglep57/node')
- *   
- *   // Configure once at startup
- *   slack.configure({
- *     webhookUrl: process.env.SLACK_ERROR_WEBHOOK,
- *     serviceName: 'tonomo-front-end',
- *     environment: process.env.NODE_ENV || 'development'
- *   })
- *   
- *   // Send error notifications
- *   await slack.error('Database connection failed', { userId: 123 })
- *   await slack.warn('Rate limit approaching', { current: 90, max: 100 })
- *   await slack.info('Deployment complete')
- */
-
-let config = null
-
-/**
- * Configure the Slack module
- * @param {Object} options
- * @param {string} options.webhookUrl - Slack incoming webhook URL
- * @param {string} options.serviceName - Name of the service (e.g., 'tonomo-front-end')
- * @param {string} [options.environment='production'] - Environment name
- */
-const configure = (options) => {
-    const { webhookUrl, serviceName, environment = 'production' } = options
-
-    if (!webhookUrl) {
-        console.warn('[slack] No webhook URL provided, notifications will be disabled')
-        config = null
-        return { configured: false }
-    }
-
-    if (!serviceName) {
-        throw new Error('slack.configure requires serviceName')
-    }
-
-    config = {
-        webhookUrl,
-        serviceName,
-        environment
-    }
-
-    return { configured: true }
-}
-
-/**
- * Check if Slack is configured
- */
-const isConfigured = () => config !== null
-
-/**
- * Send a notification to Slack
- * @param {string} level - 'error', 'warn', or 'info'
- * @param {string} message - The message
- * @param {Object} [context={}] - Additional context
- */
-const send = async (level, message, context = {}) => {
-    if (!config) {
-        return { sent: false, reason: 'not configured' }
-    }
-
-    const emoji = {
-        error: '🚨',
-        warn: '⚠️',
-        info: 'ℹ️'
-    }[level] || '📢'
-
-    const color = {
-        error: '#dc3545',
-        warn: '#ffc107',
-        info: '#17a2b8'
-    }[level] || '#6c757d'
-
-    try {
-        const contextLines = Object.entries(context)
-            .filter(([_, v]) => v !== undefined && v !== null)
-            .map(([key, value]) => {
-                const displayValue = typeof value === 'object' 
-                    ? JSON.stringify(value).substring(0, 200) 
-                    : String(value).substring(0, 200)
-                return `• *${key}:* ${displayValue}`
-            })
-            .join('\n')
-
-        const payload = {
-            attachments: [
-                {
-                    color,
-                    blocks: [
-                        {
-                            type: 'header',
-                            text: {
-                                type: 'plain_text',
-                                text: `${emoji} ${config.serviceName} - ${level.toUpperCase()}`,
-                                emoji: true
-                            }
-                        },
-                        {
-                            type: 'section',
-                            text: {
-                                type: 'mrkdwn',
-                                text: `*Message:*\n${message}`
-                            }
-                        }
-                    ]
-                }
-            ]
-        }
-
-        if (contextLines) {
-            payload.attachments[0].blocks.push({
-                type: 'section',
-                text: {
-                    type: 'mrkdwn',
-                    text: `*Context:*\n${contextLines}`
-                }
-            })
-        }
-
-        payload.attachments[0].blocks.push({
-            type: 'context',
-            elements: [
-                {
-                    type: 'mrkdwn',
-                    text: `🌍 ${config.environment} | ⏰ ${new Date().toISOString()}`
-                }
-            ]
-        })
-
-        const response = await fetch(config.webhookUrl, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload)
-        })
-
-        if (!response.ok) {
-            console.error('[slack] Failed to send notification:', response.status)
-            return { sent: false, reason: `HTTP ${response.status}` }
-        }
-
-        return { sent: true }
-    } catch (err) {
-        // Don't let Slack errors break the main flow
-        console.error('[slack] Error sending notification:', err.message)
-        return { sent: false, reason: err.message }
-    }
-}
-
-/**
- * Send an error notification
- */
-const error = (message, context = {}) => send('error', message, context)
-
-/**
- * Send a warning notification
- */
-const warn = (message, context = {}) => send('warn', message, context)
-
-/**
- * Send an info notification
- */
-const info = (message, context = {}) => send('info', message, context)
-
-/**
- * Reset configuration (useful for testing)
- */
-const reset = () => {
-    config = null
-}
-
-module.exports = {
-    configure,
-    isConfigured,
-    send,
-    error,
-    warn,
-    info,
-    reset
-}