Add webhook status polling endpoint

j3k0 · j3k0 · commit bf86727019af · 2024-10-29T06:31:39.000Z
diff --git a/app.js b/app.js
@@ -3,6 +3,8 @@ const express    = require('express');
 const cors = require('cors');
 const sessionsDB = require('./sessions-db');
 const subscriptionsDB = require('./subscriptions-db');
+const verboseLogger = require('./verboseLogger');
+const webhooksDB = require('./webhooks-db');
 
 const router = express.Router();
 router.get('/', (req, res, next) => {
@@ -60,7 +62,20 @@ function fetchUser(req, res, next) {
  */
 router.get('/me', fetchUser, (req, res, next) => {
     console.log('GET /me: ' + req.user.username);
-    res.json(req.user);
+    webhooksDB.getWebhookInfo(req.user.username, (err, webhookInfo) => {
+        if (err) {
+            console.error('Error getting webhook info:', err);
+            webhookInfo = {};
+        }
+        req.user.webhookInfo = webhookInfo;
+        const isWaiting = webhookInfo.wait_start_date && !webhookInfo.last_webhook_date || webhookInfo.last_webhook_date < webhookInfo.wait_start_date || webhookInfo.last_webhook_date > webhookInfo.wait_end_date;
+        req.user.isWaitingForWebhook = isWaiting;
+        res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
+        res.set('ETag', Date.now().toString());
+        res.set('Last-Modified', new Date().toUTCString());
+        res.status(200);
+        res.json(req.user);
+    });
 });
 
 /**
@@ -72,30 +87,63 @@ router.post('/webhooks/iaptic', (req, res, next) => {
     const body = req.body;
     console.log('POST /webhooks/iaptic: ' + JSON.stringify(body, null, 2));
     if (body.password !== process.env.IAPTIC_PASSWORD) {
+        console.log('Webhook request rejected: Invalid password');
         res.status(401);
-        res.json({ok: false});
+        res.json({ok: false, error: 'Invalid password'});
         return;
     }
     switch (body.type) {
         case 'TEST':
             res.json({ok: true, result: 'TEST_PASSED'});
             break;
         case 'purchases.updated':
+            if (!body.applicationUsername) {
+                console.log('Webhook request missing applicationUsername');
+                res.status(200);
+                res.json({ok: false, error: 'Missing applicationUsername'});
+                return;
+            }
+            // Update the last webhook date for this user
+            webhooksDB.updateWebhookInfo(body.applicationUsername, {
+                lastWebhookDate: new Date().toISOString()
+            });
             const lastPurchase = Object.values(body.purchases).reduce((lastPurchase, purchase) => {
                 if (!lastPurchase || purchase.expirationDate > lastPurchase.expirationDate) {
                     return purchase;
                 }
                 return lastPurchase;
             }, undefined);
+            if (!lastPurchase) {
+                console.log(`Removing subscription for user ${body.applicationUsername}`);
+                subscriptionsDB.remove(body.applicationUsername, (err, wasRemoved) => {
+                    res.status(200);
+                    res.json({ok: true, result: wasRemoved ? 'REMOVED' : 'NO_SUBSCRIPTION'});
+                });
+                return;
+            }
+            console.log(`Updating subscription for user ${body.applicationUsername}`);
+            console.log(`Last purchase details: ${JSON.stringify(lastPurchase, null, 2)}`);
             subscriptionsDB.update(body.applicationUsername, lastPurchase);
+            
             res.json({ok: true});
             break;
         default:
+            console.log(`Webhook request rejected: Unsupported type ${body.type}`);
             res.json({ok: true, result: 'UNSUPPORTED'});
             break;
     }
 });
 
+// Add this new endpoint for initiating webhook wait
+router.post('/pending-webhooks', fetchUser, (req, res, next) => {
+    const username = req.user.username;
+    const waitStartDate = new Date(Date.now() - 10 * 1000).toISOString(); // Assume the webbook might have been sent a few seconds ago already
+    const waitEndDate = new Date(Date.now() + 60 * 60 * 1000).toISOString(); // Wait for 1 hour
+
+    webhooksDB.updateWebhookInfo(username, { waitStartDate, waitEndDate });
+    res.json({ok: true, message: 'Webhook wait initiated'});
+});
+
 /**
  * Access public content.
  *
@@ -119,6 +167,7 @@ router.get('/content/protected/:id', fetchUser, (req, res, next) => {
     const expirationDate = req.user.subscription ? req.user.subscription.expirationDate : undefined;
     if (!expirationDate || expirationDate < new Date().toISOString())
         return res.json({error: 'NoSubscription'});
+    res.set('Cache-Control', 'no-store, no-cache, must-revalidate, private');
     res.json({
         title: 'Premium Content',
         content: 'This is some information only subscribers can access. 💰',
@@ -131,5 +180,6 @@ const app = express();
 app.use(bodyParser.json());
 app.use(bodyParser.urlencoded({ extended: false }));
 app.use(cors());
-app.use(process.env.ROUTE_PREFIX || '/demo', router);
-module.exports = app;
+app.use(verboseLogger); // Add verbose logger middleware
+app.use(prefix, router);
+module.exports = app;
diff --git a/index.js b/index.js
@@ -3,8 +3,10 @@
 const http = require('http');
 const app = require('./app');
 
+// Add a verbose mode flag
+const verboseMode = process.env.VERBOSE_MODE === 'true';
+
 const port = parseInt(process.env.PORT || '8000');
-// app.set('port', port);
 const server = http.createServer(app);
 server.on('error', onError);
 server.on('listening', onListening);
@@ -42,5 +44,23 @@ function onListening() {
     ? 'pipe ' + addr
     : 'port ' + addr.port;
   console.log('Listening on ' + bind);
+  
+  // Add verbose logging
+  if (verboseMode) {
+    console.log('Verbose mode enabled');
+    console.log('Server configuration:');
+    console.log(`- Port: ${port}`);
+    console.log(`- Route prefix: ${process.env.ROUTE_PREFIX || '/demo'}`);
+    console.log(`- Iaptic password set: ${!!process.env.IAPTIC_PASSWORD}`);
+    console.log('Environment variables:');
+    Object.keys(process.env).forEach(key => {
+      if (key !== 'IAPTIC_PASSWORD') { // Don't log sensitive information
+        console.log(`- ${key}: ${process.env[key]}`);
+      }
+    });
+  }
 }
 
+// Export the verboseLogger for use in app.js
+module.exports = { server };
+
diff --git a/subscriptions-db.js b/subscriptions-db.js
@@ -50,4 +50,17 @@ function fetch(username, callback) {
     });
 }
 
-module.exports = {update, fetch}
+function remove(username, callback) {
+  db.run('DELETE FROM subscriptions WHERE username = ?', [username], function(err) {
+    if (err) {
+      console.error('Error attempting to delete subscription:', err);
+      callback(err);
+      return;
+    }
+    const wasDeleted = this.changes > 0;
+    console.log(`Subscription for user ${username} ${wasDeleted ? 'deleted successfully' : 'not found or already deleted'}.`);
+    callback(null, wasDeleted);
+  });
+}
+
+module.exports = {update, fetch, remove}
diff --git a/verboseLogger.js b/verboseLogger.js
@@ -0,0 +1,44 @@
+const verboseMode = process.env.VERBOSE_MODE === 'true';
+
+function verboseLogger(req, res, next) {
+  if (verboseMode) {
+    const timestamp = new Date().toISOString();
+    const method = req.method;
+    const url = req.url;
+    const ip = req.ip || req.connection.remoteAddress;
+    const userAgent = req.get('User-Agent');
+
+    console.log(`[${timestamp}] ${method} ${url}`);
+    console.log(`  IP: ${ip}`);
+    console.log(`  User-Agent: ${userAgent}`);
+    
+    if (Object.keys(req.query).length > 0) {
+      console.log('  Query params:', req.query);
+    }
+    
+    if (req.body && Object.keys(req.body).length > 0) {
+      console.log('  Body:', JSON.stringify(req.body, null, 2));
+    }
+
+    // Capture the original json method
+    const originalJson = res.json;
+
+    // Override the json method
+    res.json = function(body) {
+      // Log the response body
+      console.log('  Response:', JSON.stringify(body, null, 2));
+
+      // Call the original json method
+      originalJson.call(this, body);
+    };
+
+    // Log when the response is finished
+    res.on('finish', () => {
+      console.log(`  Status: ${res.statusCode}`);
+      console.log('---');
+    });
+  }
+  next();
+}
+
+module.exports = verboseLogger;
diff --git a/webhooks-db.js b/webhooks-db.js
@@ -0,0 +1,91 @@
+/**
+ * WebhooksDB to track webhook information for users.
+ */
+
+const sqlite3 = require('sqlite3');
+const db = new sqlite3.Database('webhooks.db');
+
+db.run(`CREATE TABLE IF NOT EXISTS webhooks (
+    username TEXT PRIMARY KEY,
+    last_webhook_date TEXT,
+    wait_start_date TEXT,
+    wait_end_date TEXT
+)`);
+
+/**
+ * Update webhook information for a user
+ * @param {string} username - The user's identifier
+ * @param {Object} data - Object containing webhook data
+ * @param {string} [data.lastWebhookDate] - ISO8601 formatted date string of the last received webhook
+ * @param {string} [data.waitStartDate] - ISO8601 formatted date string for when to start waiting
+ * @param {string} [data.waitEndDate] - ISO8601 formatted date string for when to stop waiting
+ */
+function updateWebhookInfo(username, data) {
+    const { lastWebhookDate, waitStartDate, waitEndDate } = data;
+    db.run(`INSERT OR REPLACE INTO webhooks 
+        (username, last_webhook_date, wait_start_date, wait_end_date) 
+        VALUES (?, 
+            COALESCE(?, (SELECT last_webhook_date FROM webhooks WHERE username = ?)),
+            COALESCE(?, (SELECT wait_start_date FROM webhooks WHERE username = ?)),
+            COALESCE(?, (SELECT wait_end_date FROM webhooks WHERE username = ?))
+        )`,
+        username, 
+        lastWebhookDate, username,
+        waitStartDate, username,
+        waitEndDate, username
+    );
+}
+
+/**
+ * Get webhook information for a user
+ * @param {string} username - The user's identifier
+ * @param {function} callback - Callback function(err, webhookInfo)
+ */
+function getWebhookInfo(username, callback) {
+    db.get('SELECT * FROM webhooks WHERE username = ?', 
+        [username],
+        (err, row) => {
+            if (err) {
+                callback(err, null);
+            } else {
+                callback(null, row || {});
+            }
+        }
+    );
+}
+
+/**
+ * Check if a user is waiting for a webhook
+ * @param {string} username - The user's identifier
+ * @param {function} callback - Callback function(err, isWaiting)
+ *
+function isWaitingForWebhook(username, callback) {
+    const now = new Date().toISOString();
+    db.get('SELECT * FROM webhooks WHERE username = ? AND wait_start_date <= ? AND wait_end_date > ?', 
+        [username, now, now],
+        (err, row) => {
+            if (err) {
+                callback(err, false);
+            } else {
+                callback(null, !!row);
+            }
+        }
+    );
+}
+*/
+
+/**
+ * Clean up expired webhook waits
+ */
+function cleanupExpiredWaits() {
+    const now = new Date().toISOString();
+    db.run('UPDATE webhooks SET wait_start_date = NULL, wait_end_date = NULL WHERE wait_end_date <= ?', now);
+}
+
+// Run cleanup periodically (e.g., every hour)
+setInterval(cleanupExpiredWaits, 60 * 60 * 1000);
+
+module.exports = {
+    updateWebhookInfo,
+    getWebhookInfo
+};
