dzql 0.1.5 → 0.2.0

package/src/server/subscriptions.js

@@ -0,0 +1,209 @@
+/**
+ * Subscription Manager for Live Query Subscriptions
+ * Manages in-memory subscription registry and matching
+ */
+
+import crypto from 'crypto';
+import { wsLogger } from './logger.js';
+
+/**
+ * In-memory subscription registry
+ * Structure: subscription_id -> { subscribable, user_id, connection_id, params }
+ */
+const subscriptions = new Map();
+
+/**
+ * Track subscriptions by connection for cleanup
+ * Structure: connection_id -> Set<subscription_id>
+ */
+const connectionSubscriptions = new Map();
+
+/**
+ * Register a new subscription
+ * @param {string} subscribableName - Name of the subscribable
+ * @param {number} userId - User ID
+ * @param {string} connectionId - WebSocket connection ID
+ * @param {object} params - Subscription parameters
+ * @returns {string} - Subscription ID
+ */
+export function registerSubscription(subscribableName, userId, connectionId, params) {
+  const subscriptionId = crypto.randomUUID();
+
+  // Store subscription
+  subscriptions.set(subscriptionId, {
+    subscribable: subscribableName,
+    user_id: userId,
+    connection_id: connectionId,
+    params,
+    created_at: new Date()
+  });
+
+  // Track by connection
+  if (!connectionSubscriptions.has(connectionId)) {
+    connectionSubscriptions.set(connectionId, new Set());
+  }
+  connectionSubscriptions.get(connectionId).add(subscriptionId);
+
+  wsLogger.debug(`Subscription registered: ${subscriptionId.slice(0, 8)}... (${subscribableName})`, {
+    user_id: userId,
+    params
+  });
+
+  return subscriptionId;
+}
+
+/**
+ * Unregister a subscription
+ * @param {string} subscriptionId - Subscription ID to remove
+ * @returns {boolean} - True if subscription was found and removed
+ */
+export function unregisterSubscription(subscriptionId) {
+  const sub = subscriptions.get(subscriptionId);
+
+  if (!sub) {
+    wsLogger.debug(`Subscription not found: ${subscriptionId}`);
+    return false;
+  }
+
+  // Remove from connection tracking
+  const connSubs = connectionSubscriptions.get(sub.connection_id);
+  if (connSubs) {
+    connSubs.delete(subscriptionId);
+    if (connSubs.size === 0) {
+      connectionSubscriptions.delete(sub.connection_id);
+    }
+  }
+
+  // Remove subscription
+  subscriptions.delete(subscriptionId);
+
+  wsLogger.debug(`Subscription removed: ${subscriptionId.slice(0, 8)}...`);
+  return true;
+}
+
+/**
+ * Unregister subscription by params
+ * Useful for unsubscribe_* methods that specify params instead of subscription ID
+ * @param {string} subscribableName - Name of the subscribable
+ * @param {string} connectionId - WebSocket connection ID
+ * @param {object} params - Subscription parameters to match
+ * @returns {boolean} - True if subscription was found and removed
+ */
+export function unregisterSubscriptionByParams(subscribableName, connectionId, params) {
+  const paramsStr = JSON.stringify(params);
+
+  // Find matching subscription
+  for (const [subId, sub] of subscriptions.entries()) {
+    if (
+      sub.subscribable === subscribableName &&
+      sub.connection_id === connectionId &&
+      JSON.stringify(sub.params) === paramsStr
+    ) {
+      return unregisterSubscription(subId);
+    }
+  }
+
+  wsLogger.debug(`No matching subscription found for ${subscribableName} with params`, params);
+  return false;
+}
+
+/**
+ * Remove all subscriptions for a connection
+ * Called when WebSocket connection closes
+ * @param {string} connectionId - Connection ID
+ * @returns {number} - Number of subscriptions removed
+ */
+export function removeConnectionSubscriptions(connectionId) {
+  const subIds = connectionSubscriptions.get(connectionId);
+
+  if (!subIds) {
+    return 0;
+  }
+
+  let count = 0;
+  for (const subId of subIds) {
+    if (subscriptions.delete(subId)) {
+      count++;
+    }
+  }
+
+  connectionSubscriptions.delete(connectionId);
+
+  if (count > 0) {
+    wsLogger.info(`Removed ${count} subscription(s) for connection ${connectionId.slice(0, 8)}...`);
+  }
+
+  return count;
+}
+
+/**
+ * Get all subscriptions for a specific subscribable
+ * @param {string} subscribableName - Name of the subscribable
+ * @returns {Array} - Array of {subscriptionId, subscription} objects
+ */
+export function getSubscriptionsByName(subscribableName) {
+  const result = [];
+
+  for (const [subId, sub] of subscriptions.entries()) {
+    if (sub.subscribable === subscribableName) {
+      result.push({ subscriptionId: subId, ...sub });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get all subscriptions grouped by subscribable name
+ * @returns {Map<string, Array>} - Map of subscribable name to array of subscriptions
+ */
+export function getSubscriptionsBySubscribable() {
+  const grouped = new Map();
+
+  for (const [subId, sub] of subscriptions.entries()) {
+    if (!grouped.has(sub.subscribable)) {
+      grouped.set(sub.subscribable, []);
+    }
+    grouped.get(sub.subscribable).push({ subscriptionId: subId, ...sub });
+  }
+
+  return grouped;
+}
+
+/**
+ * Check if params match (deep equality)
+ * @param {object} a - First params object
+ * @param {object} b - Second params object
+ * @returns {boolean} - True if params match
+ */
+export function paramsMatch(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+/**
+ * Get subscription statistics
+ * @returns {object} - Stats object
+ */
+export function getStats() {
+  return {
+    total_subscriptions: subscriptions.size,
+    active_connections: connectionSubscriptions.size,
+    subscriptions_by_subscribable: Array.from(getSubscriptionsBySubscribable().entries()).map(
+      ([name, subs]) => ({
+        name,
+        count: subs.length
+      })
+    )
+  };
+}
+
+/**
+ * Get all active subscriptions (for debugging)
+ * @returns {Array} - Array of all subscriptions
+ */
+export function getAllSubscriptions() {
+  return Array.from(subscriptions.entries()).map(([id, sub]) => ({
+    id,
+    ...sub
+  }));
+}

package/src/server/ws.js

@@ -6,6 +6,12 @@ import {
   db,
 } from "./db.js";
 import { wsLogger, authLogger } from "./logger.js";
+import {
+  registerSubscription,
+  unregisterSubscription,
+  unregisterSubscriptionByParams,
+  removeConnectionSubscriptions
+} from "./subscriptions.js";
 
 // Environment configuration
 const JWT_SECRET_STRING = process.env.JWT_SECRET;
@@ -304,6 +310,57 @@ export function createRPCHandler(customHandlers = {}) {
         return create_rpc_response(id, result);
       }
 
+      // SUBSCRIPTION HANDLERS - Pattern match on method name
+      if (method.startsWith("subscribe_")) {
+        const subscribableName = method.replace("subscribe_", "");
+        wsLogger.debug(`Subscribe request: ${subscribableName}`, params);
+
+        try {
+          // Execute initial query (this also checks permissions)
+          const queryResult = await db.query(
+            `SELECT get_${subscribableName}($1, $2) as data`,
+            [params, ws.data.user_id]
+          );
+
+          const data = queryResult.rows[0]?.data;
+
+          // Register subscription in memory
+          const subscriptionId = registerSubscription(
+            subscribableName,
+            ws.data.user_id,
+            ws.data.connection_id,
+            params
+          );
+
+          const result = {
+            subscription_id: subscriptionId,
+            data
+          };
+
+          wsLogger.response(method, result, Date.now() - startTime);
+          return create_rpc_response(id, result);
+        } catch (error) {
+          wsLogger.error(`Subscribe failed for ${subscribableName}:`, error.message);
+          return create_rpc_error(id, -32603, error.message);
+        }
+      }
+
+      if (method.startsWith("unsubscribe_")) {
+        const subscribableName = method.replace("unsubscribe_", "");
+        wsLogger.debug(`Unsubscribe request: ${subscribableName}`, params);
+
+        // Remove subscription by params
+        const removed = unregisterSubscriptionByParams(
+          subscribableName,
+          ws.data.connection_id,
+          params
+        );
+
+        const result = { success: removed };
+        wsLogger.response(method, result, Date.now() - startTime);
+        return create_rpc_response(id, result);
+      }
+
       // Check for custom handlers
       if (customHandlers[method]) {
         wsLogger.debug(`Calling custom handler: ${method}`);
@@ -417,7 +474,14 @@ export function createWebSocketHandlers(options = {}) {
     close(ws) {
       const id = ws.data.connection_id;
       connections.delete(id);
-      wsLogger.info(`Connection closed: ${id?.slice(0, 8)}...`);
+
+      // Clean up all subscriptions for this connection
+      const removedCount = removeConnectionSubscriptions(id);
+      if (removedCount > 0) {
+        wsLogger.info(`Connection closed: ${id?.slice(0, 8)}... (${removedCount} subscriptions removed)`);
+      } else {
+        wsLogger.info(`Connection closed: ${id?.slice(0, 8)}...`);
+      }
 
       // Call custom disconnection handler
       if (onDisconnection) {
@@ -434,7 +498,7 @@ export function createWebSocketHandlers(options = {}) {
 
 // Broadcast message to all authenticated connections or specific client_ids
 export function createBroadcaster(connections) {
-  return function broadcastToConnections(message, client_ids = null) {
+  const broadcastToConnections = function(message, client_ids = null) {
     if (client_ids && Array.isArray(client_ids)) {
       // Send to specific user_ids
       for (const [id, ws] of connections) {
@@ -451,6 +515,18 @@ export function createBroadcaster(connections) {
       }
     }
   };
+
+  // Add helper function to send to a specific connection
+  broadcastToConnections.toConnection = function(connectionId, message) {
+    const ws = connections.get(connectionId);
+    if (ws && ws.readyState === 1) { // 1 = OPEN
+      ws.send(message);
+      return true;
+    }
+    return false;
+  };
+
+  return broadcastToConnections;
 }
 
 // Legacy export for backward compatibility

package/src/client/ui-configs/sample-2.js

@@ -1,207 +0,0 @@
-// Rights Management UI Configuration
-export const uiConfig = {
-    type: 'container',
-    class: 'app',
-    children: [
-        // Header
-        {
-            type: 'div',
-            class: 'header',
-            children: [
-                { type: 'h1', text: '🏛️ Rights Management' },
-                { type: 'p', text: 'Manage venues, packages, and contractor rights' },
-                {
-                    type: 'span',
-                    class: '${state.wsStatus === "connected" ? "status connected" : "status disconnected"}',
-                    text: '${state.wsStatus || "disconnected"}'
-                }
-            ]
-        },
-
-        // Navigation tabs
-        {
-            type: 'div',
-            class: 'nav-bar',
-            children: [{
-                type: 'div',
-                class: 'nav-tabs',
-                children: [
-                    'dashboard', 'organisations', 'venues', 'packages', 'allocations', 'rights'
-                ].map(tab => ({
-                    type: 'button',
-                    class: '${state.activeTab === "' + tab + '" ? "tab active" : "tab"}',
-                    text: tab.charAt(0).toUpperCase() + tab.slice(1),
-                    onClick: {
-                        actions: [
-                            { type: 'setState', path: 'activeTab', value: tab },
-                            tab !== 'dashboard' ? {
-                                type: 'call',
-                                operation: 'search',
-                                entity: tab === 'rights' ? 'contractor_rights' : tab,
-                                params: { limit: 25 },
-                                resultPath: tab + '.list'
-                            } : null
-                        ].filter(Boolean)
-                    }
-                }))
-            }]
-        },
-
-        // Content area
-        {
-            type: 'div',
-            class: 'content',
-            children: [
-                // Dashboard
-                {
-                    type: 'if',
-                    condition: "${state.activeTab === 'dashboard'}",
-                    then: {
-                        type: 'section',
-                        children: [
-                            { type: 'h2', text: 'Dashboard' },
-                            {
-                                type: 'div',
-                                class: 'grid',
-                                children: ['venues', 'packages', 'allocations', 'organisations'].map(entity => ({
-                                    type: 'div',
-                                    class: 'card',
-                                    children: [
-                                        { type: 'h3', text: entity.charAt(0).toUpperCase() + entity.slice(1) },
-                                        { type: 'div', class: 'stat-value', text: '${state.stats?.' + entity + ' || "..."}' },
-                                        { type: 'div', class: 'stat-label', text: 'Total ' + entity }
-                                    ]
-                                }))
-                            }
-                        ]
-                    }
-                },
-
-                // Entity views (organisations, venues, packages, allocations)
-                ...['organisations', 'venues', 'packages', 'allocations'].map(entity => ({
-                    type: 'if',
-                    condition: "${state.activeTab === '" + entity + "'}",
-                    then: {
-                        type: 'section',
-                        children: [
-                            { type: 'h2', text: entity.charAt(0).toUpperCase() + entity.slice(1) },
-                            {
-                                type: 'div',
-                                class: 'search-bar',
-                                children: [
-                                    {
-                                        type: 'input',
-                                        bind: '${state.' + entity + '.search}',
-                                        attributes: { placeholder: 'Search ' + entity + '...' }
-                                    },
-                                    {
-                                        type: 'button',
-                                        text: 'Search',
-                                        onClick: {
-                                            actions: [{
-                                                type: 'call',
-                                                operation: 'search',
-                                                entity: entity,
-                                                params: {
-                                                    filters: { _search: '${state.' + entity + '.search}' },
-                                                    limit: 25
-                                                },
-                                                resultPath: entity + '.list'
-                                            }]
-                                        }
-                                    }
-                                ]
-                            },
-                            {
-                                type: 'if',
-                                condition: '${state.' + entity + '.list}',
-                                then: {
-                                    type: 'table',
-                                    data: '${state.' + entity + '.list.data}',
-                                    columns: getColumnsForEntity(entity)
-                                }
-                            }
-                        ]
-                    }
-                })),
-
-                // Rights view
-                {
-                    type: 'if',
-                    condition: "${state.activeTab === 'rights'}",
-                    then: {
-                        type: 'section',
-                        children: [
-                            { type: 'h2', text: 'Rights Management' },
-                            {
-                                type: 'div',
-                                class: 'pill-nav',
-                                children: ['contractor', 'promotion'].map(type => ({
-                                    type: 'button',
-                                    class: '${state.rightsType === "' + type + '" ? "pill active" : "pill"}',
-                                    text: type.charAt(0).toUpperCase() + type.slice(1) + ' Rights',
-                                    onClick: {
-                                        actions: [
-                                            { type: 'setState', path: 'rightsType', value: type },
-                                            {
-                                                type: 'call',
-                                                operation: 'search',
-                                                entity: type + '_rights',
-                                                params: { limit: 25 },
-                                                resultPath: 'rights.' + type
-                                            }
-                                        ]
-                                    }
-                                }))
-                            },
-                            {
-                                type: 'if',
-                                condition: '${state.rights.contractor}',
-                                then: {
-                                    type: 'table',
-                                    data: '${state.rights.contractor.data}',
-                                    columns: [
-                                        { field: 'contractor_org.name', label: 'Contractor' },
-                                        { field: 'venue.name', label: 'Venue' },
-                                        { field: 'valid_from', label: 'From' },
-                                        { field: 'valid_to', label: 'To' }
-                                    ]
-                                }
-                            }
-                        ]
-                    }
-                }
-            ]
-        }
-    ]
-};
-
-// Helper function for table columns
-function getColumnsForEntity(entity) {
-    const columnSets = {
-        organisations: [
-            { field: 'id', label: 'ID' },
-            { field: 'name', label: 'Name' },
-            { field: 'description', label: 'Description' }
-        ],
-        venues: [
-            { field: 'id', label: 'ID' },
-            { field: 'name', label: 'Name' },
-            { field: 'address', label: 'Address' },
-            { field: 'org.name', label: 'Organisation' }
-        ],
-        packages: [
-            { field: 'id', label: 'ID' },
-            { field: 'name', label: 'Name' },
-            { field: 'owner.name', label: 'Owner' },
-            { field: 'sponsor.name', label: 'Sponsor' }
-        ],
-        allocations: [
-            { field: 'id', label: 'ID' },
-            { field: 'package.name', label: 'Package' },
-            { field: 'site.name', label: 'Site' },
-            { field: 'from_datetime', label: 'From' }
-        ]
-    };
-    return columnSets[entity] || [];
-}