🔧 update: enhance platform source detection and add unit tests

Author: warengonzaga

.contributerc.json

@@ -0,0 +1,17 @@
+{
+  "workflow": "clean-flow",
+  "role": "maintainer",
+  "mainBranch": "main",
+  "devBranch": "dev",
+  "upstream": "upstream",
+  "origin": "origin",
+  "branchPrefixes": [
+    "feature",
+    "fix",
+    "docs",
+    "chore",
+    "test",
+    "refactor"
+  ],
+  "commitConvention": "clean-commit"
+}

.gitignore

@@ -152,3 +152,5 @@ yarn.lock
 context/
 # Snyk Security Extension - AI Rules (auto-generated)
 .github/instructions/snyk_rules.instructions.md
+
+.contributerc.json

package.json

@@ -40,7 +40,7 @@
     "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@wgtechlabs/log-engine": "2.2.0",
+    "@wgtechlabs/log-engine": "2.3.1",
     "dotenv": "^16.4.0",
     "express": "^4.21.0",
     "express-validator": "^7.3.1",

pnpm-lock.yaml

@@ -11,9 +11,13 @@ import { validateEvent } from './middleware/validation';
 import { WebhookRequest } from './types';
 import { RedisService } from './services/redisService';
 
-// Configure LogEngine to use only local time (no ISO timestamp)
+// Configure LogEngine with no timestamps (emoji + level + message only)
 LogEngine.configure({ 
-  mode: LogMode.DEBUG
+  mode: LogMode.DEBUG,
+  format: {
+    includeIsoTimestamp: false,
+    includeLocalTime: false
+  }
 });
 
 const app = express();

src/app.ts

@@ -36,6 +36,7 @@ export const redisEventConfig = {
     // Event tracking configuration
     eventTtl: 259200, // 3 days (72 hours * 60 minutes * 60 seconds)
     keyPrefix: 'unthread:eventid:',
+    fingerprintPrefix: 'unthread:fp:',
 };
 
 // Create Redis client for v4.x - use URL string directly with timeout

src/config/redis.ts

@@ -17,7 +17,7 @@ export class WebhookController {
     static initializeBackgroundProcessor(): void {
         if (!WebhookController.backgroundProcessor) {
             WebhookController.backgroundProcessor = new WebhookController();
-            LogEngine.log('🔄 Background webhook processor initialized');
+            LogEngine.log('Background webhook processor initialized');
         }
     }
 
@@ -34,7 +34,7 @@ export class WebhookController {
             const { event, eventId } = req.body;
 
             // Log raw incoming webhook data
-            LogEngine.debug(`🌐 RAW WEBHOOK RECEIVED:`, {
+            LogEngine.debug(`RAW WEBHOOK RECEIVED:`, {
                 eventId,
                 completeRawData: req.body
             });
@@ -48,7 +48,7 @@ export class WebhookController {
             // Quick validation only - no heavy processing
             const validationResult = this.webhookService.validateEvent(req.body);
             if (!validationResult.isValid) {
-                LogEngine.error(`❌ Event validation failed:`, validationResult.errors);
+                LogEngine.error(`Event validation failed:`, validationResult.errors);
                 return res.status(400).json({ 
                     error: 'Invalid event structure',
                     details: validationResult.errors 
@@ -71,7 +71,7 @@ export class WebhookController {
             // Queue event for background processing (non-blocking)
             this.queueEventForBackgroundProcessing(req.body, requestId);
 
-            LogEngine.debug(`⚡ Immediate response sent`, {
+            LogEngine.debug(`Immediate response sent`, {
                 eventId,
                 requestId,
                 responseTime: `${responseTime}ms`
@@ -81,7 +81,7 @@ export class WebhookController {
 
         } catch (error) {
             const responseTime = Date.now() - startTime;
-            LogEngine.error(`💥 Error handling webhook: ${error}`);
+            LogEngine.error(`Error handling webhook: ${error}`);
             return res.status(500).json({
                 error: 'Internal server error',
                 responseTime: `${responseTime}ms`,
@@ -106,12 +106,12 @@ export class WebhookController {
                         await this.processEventInBackground(event, requestId);
                     }
                 } catch (error) {
-                    LogEngine.error(`💥 Background processing failed:`, {
+                    LogEngine.error(`Background processing failed:`, {
                         requestId,
                         eventId: event?.eventId,
-                    error: error instanceof Error ? error.message : 'Unknown error'
-                });
-            }
+                        error: error instanceof Error ? error.message : 'Unknown error'
+                    });
+                }
             })();
         });
     }
@@ -123,7 +123,7 @@ export class WebhookController {
         const startTime = Date.now();
 
         try {
-            LogEngine.debug(`🔄 Background processing started`, {
+            LogEngine.debug(`Background processing started`, {
                 eventId: event?.eventId,
                 requestId
             });
@@ -133,15 +133,15 @@ export class WebhookController {
             await this.webhookService.processEvent(event);
 
             const processingTime = Date.now() - startTime;
-            LogEngine.info(`✅ Background processing completed`, {
+            LogEngine.info(`Background processing completed`, {
                 eventId: event?.eventId,
                 requestId,
                 processingTime: `${processingTime}ms`
             });
 
         } catch (error) {
             const processingTime = Date.now() - startTime;
-            LogEngine.error(`💥 Background processing failed:`, {
+            LogEngine.error(`Background processing failed:`, {
                 eventId: event?.eventId,
                 requestId,
                 processingTime: `${processingTime}ms`,

src/controllers/webhookController.ts

@@ -46,31 +46,53 @@ export class RedisService {
             const eventJson = JSON.stringify(event);
 
             // Log the complete transformed event data
-            LogEngine.debug(`⚡ TRANSFORMED WEBHOOK EVENT:`, {
+            LogEngine.debug(`TRANSFORMED WEBHOOK EVENT:`, {
                 eventId: event.data?.eventId || 'unknown',
                 completeTransformedData: event
             });
 
             // Use Redis LIST for FIFO queue (LPUSH + BRPOP pattern)
             const result = await this.client.lPush(queueName, eventJson);
 
-            LogEngine.info(`✅ Event successfully queued: ${event.data?.eventId || 'unknown'} -> ${queueName} (${result} items in queue)`);
+            LogEngine.info(`Event successfully queued: ${event.data?.eventId || 'unknown'} -> ${queueName} (${result} items in queue)`);
             return result;
         } catch (err) {
             LogEngine.error(`Error publishing event to queue: ${err}`);
             throw err;
         }
     }
 
+    /**
+     * Check if a key exists in Redis
+     * @param prefix - Key prefix (e.g., eventId or fingerprint prefix)
+     * @param id - Unique identifier to check
+     * @returns Promise<boolean> - true if key exists
+     */
+    private async keyExists(prefix: string, id: string): Promise<boolean> {
+        const key = `${prefix}${id}`;
+        const exists = await this.client.exists(key);
+        return exists === 1;
+    }
+
+    /**
+     * Mark a key as processed with automatic expiration
+     * @param prefix - Key prefix (e.g., eventId or fingerprint prefix)
+     * @param id - Unique identifier to mark
+     * @param ttlSeconds - Time to live in seconds (default: 3 days from config)
+     */
+    private async markKey(prefix: string, id: string, ttlSeconds?: number): Promise<void> {
+        const key = `${prefix}${id}`;
+        const ttl = ttlSeconds || redisEventConfig.eventTtl;
+        await this.client.setEx(key, ttl, 'processed');
+    }
+
     /**
      * Check if webhook event already exists (duplicate detection)
      * @param eventId - Unique event identifier
      * @returns Promise<boolean> - true if event exists
      */
     async eventExists(eventId: string): Promise<boolean> {
-        const key = `${redisEventConfig.keyPrefix}${eventId}`;
-        const exists = await this.client.exists(key);
-        return exists === 1;
+        return this.keyExists(redisEventConfig.keyPrefix, eventId);
     }
 
     /**
@@ -79,9 +101,23 @@ export class RedisService {
      * @param ttlSeconds - Time to live in seconds (default: 3 days from config)
      */
     async markEventProcessed(eventId: string, ttlSeconds?: number): Promise<void> {
-        const key = `${redisEventConfig.keyPrefix}${eventId}`;
-        const ttl = ttlSeconds || redisEventConfig.eventTtl; // 3 days default
-        await this.client.setEx(key, ttl, 'processed');
+        return this.markKey(redisEventConfig.keyPrefix, eventId, ttlSeconds);
+    }
+
+    /**
+     * Atomically claim a composite fingerprint slot (SET NX pattern).
+     * Combines existence check and marking into a single atomic Redis operation,
+     * eliminating the race window between check and mark.
+     * 
+     * @param fingerprint - Composite key: eventTimestamp:event:data.id
+     * @param ttlSeconds - Time to live in seconds (default: 3 days from config)
+     * @returns Promise<boolean> - true if claimed (new), false if already exists (duplicate)
+     */
+    async claimFingerprint(fingerprint: string, ttlSeconds?: number): Promise<boolean> {
+        const key = `${redisEventConfig.fingerprintPrefix}${fingerprint}`;
+        const ttl = ttlSeconds || redisEventConfig.eventTtl;
+        const result = await this.client.set(key, 'processed', { EX: ttl, NX: true });
+        return result !== null;
     }
 
     async close(): Promise<void> {