@comergehq/studio 0.1.21 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comergehq/studio",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "Comerge studio",
   "main": "src/index.ts",
   "module": "dist/index.mjs",

package/src/core/services/supabase/realtimeManager.ts

@@ -0,0 +1,112 @@
+import { log } from '../../logger';
+import { getSupabaseClient } from './client';
+
+type SupabaseClient = ReturnType<typeof getSupabaseClient>;
+type RealtimeChannel = ReturnType<SupabaseClient['channel']>;
+type ChannelConfigurer = (channel: RealtimeChannel) => void;
+
+type ChannelEntry = {
+  key: string;
+  channel: RealtimeChannel | null;
+  subscribers: Map<number, ChannelConfigurer>;
+  backoffMs: number;
+  timer: ReturnType<typeof setTimeout> | null;
+};
+
+const INITIAL_BACKOFF_MS = 1000;
+const MAX_BACKOFF_MS = 30000;
+
+const realtimeLog = log.extend('realtime');
+const entries = new Map<string, ChannelEntry>();
+let subscriberIdCounter = 0;
+
+function clearTimer(entry: ChannelEntry) {
+  if (!entry.timer) return;
+  clearTimeout(entry.timer);
+  entry.timer = null;
+}
+
+function buildChannel(entry: ChannelEntry): RealtimeChannel {
+  const supabase = getSupabaseClient();
+  const channel = supabase.channel(entry.key);
+  entry.subscribers.forEach((configure) => {
+    configure(channel);
+  });
+  return channel;
+}
+
+function scheduleResubscribe(entry: ChannelEntry, reason: string) {
+  if (entry.timer) return;
+  const delay = entry.backoffMs;
+  entry.backoffMs = Math.min(entry.backoffMs * 2, MAX_BACKOFF_MS);
+  realtimeLog.warn(`[realtime] channel ${entry.key} ${reason}; resubscribe in ${delay}ms`);
+  entry.timer = setTimeout(() => {
+    entry.timer = null;
+    if (!entries.has(entry.key)) return;
+    if (entry.subscribers.size === 0) return;
+    subscribeChannel(entry);
+  }, delay);
+}
+
+function handleStatus(entry: ChannelEntry, status: string) {
+  if (status === 'SUBSCRIBED') {
+    entry.backoffMs = INITIAL_BACKOFF_MS;
+    clearTimer(entry);
+    return;
+  }
+  if (status === 'CLOSED' || status === 'TIMED_OUT' || status === 'CHANNEL_ERROR') {
+    scheduleResubscribe(entry, status);
+  }
+}
+
+function subscribeChannel(entry: ChannelEntry) {
+  try {
+    const supabase = getSupabaseClient();
+    if (entry.channel) supabase.removeChannel(entry.channel);
+    const channel = buildChannel(entry);
+    entry.channel = channel;
+    channel.subscribe((status) => handleStatus(entry, status));
+  } catch (error) {
+    realtimeLog.warn('[realtime] subscribe failed', error);
+    scheduleResubscribe(entry, 'SUBSCRIBE_FAILED');
+  }
+}
+
+export function subscribeManagedChannel(key: string, configure: ChannelConfigurer): () => void {
+  let entry = entries.get(key);
+  if (!entry) {
+    entry = {
+      key,
+      channel: null,
+      subscribers: new Map(),
+      backoffMs: INITIAL_BACKOFF_MS,
+      timer: null,
+    };
+    entries.set(key, entry);
+  }
+
+  const subscriberId = ++subscriberIdCounter;
+  entry.subscribers.set(subscriberId, configure);
+
+  if (!entry.channel) {
+    subscribeChannel(entry);
+  } else {
+    configure(entry.channel);
+  }
+
+  return () => {
+    const current = entries.get(key);
+    if (!current) return;
+    current.subscribers.delete(subscriberId);
+    if (current.subscribers.size === 0) {
+      clearTimer(current);
+      try {
+        if (current.channel) getSupabaseClient().removeChannel(current.channel);
+      } finally {
+        entries.delete(key);
+      }
+      return;
+    }
+    subscribeChannel(current);
+  };
+}

package/src/data/apps/edit-queue/repository.ts

@@ -2,7 +2,7 @@ import type { EditQueueRemoteDataSource } from './remote';
 import { editQueueRemoteDataSource } from './remote';
 import type { EditQueueItem, EditQueueListResponse, UpdateEditQueueItemRequest } from './types';
 import { BaseRepository } from '../../base-repository';
-import { getSupabaseClient } from '../../../core/services/supabase';
+import { subscribeManagedChannel } from '../../../core/services/supabase/realtimeManager';
 import type { AttachmentMeta } from '../../attachment/types';
 
 type DbAppJobQueueRow = {
@@ -89,45 +89,40 @@ class EditQueueRepositoryImpl extends BaseRepository implements EditQueueReposit
       onDelete?: (item: EditQueueItem) => void;
     }
   ): () => void {
-    const supabase = getSupabaseClient();
-    const channel = supabase
-      .channel(`edit-queue:app:${appId}`)
-      .on(
-        'postgres_changes',
-        { event: 'INSERT', schema: 'public', table: 'app_job_queue', filter: `app_id=eq.${appId}` },
-        (payload) => {
-          const row = payload.new as DbAppJobQueueRow;
-          if (row.kind !== 'edit') return;
-          const item = mapQueueItem(row);
-          if (!ACTIVE_STATUSES.includes(item.status)) return;
-          handlers.onInsert?.(item);
-        }
-      )
-      .on(
-        'postgres_changes',
-        { event: 'UPDATE', schema: 'public', table: 'app_job_queue', filter: `app_id=eq.${appId}` },
-        (payload) => {
-          const row = payload.new as DbAppJobQueueRow;
-          if (row.kind !== 'edit') return;
-          const item = mapQueueItem(row);
-          if (ACTIVE_STATUSES.includes(item.status)) handlers.onUpdate?.(item);
-          else handlers.onDelete?.(item);
-        }
-      )
-      .on(
-        'postgres_changes',
-        { event: 'DELETE', schema: 'public', table: 'app_job_queue', filter: `app_id=eq.${appId}` },
-        (payload) => {
-          const row = payload.old as DbAppJobQueueRow;
-          if (row.kind !== 'edit') return;
-          handlers.onDelete?.(mapQueueItem(row));
-        }
-      )
-      .subscribe();
-
-    return () => {
-      supabase.removeChannel(channel);
-    };
+    return subscribeManagedChannel(`edit-queue:app:${appId}`, (channel) => {
+      channel
+        .on(
+          'postgres_changes',
+          { event: 'INSERT', schema: 'public', table: 'app_job_queue', filter: `app_id=eq.${appId}` },
+          (payload) => {
+            const row = payload.new as DbAppJobQueueRow;
+            if (row.kind !== 'edit') return;
+            const item = mapQueueItem(row);
+            if (!ACTIVE_STATUSES.includes(item.status)) return;
+            handlers.onInsert?.(item);
+          }
+        )
+        .on(
+          'postgres_changes',
+          { event: 'UPDATE', schema: 'public', table: 'app_job_queue', filter: `app_id=eq.${appId}` },
+          (payload) => {
+            const row = payload.new as DbAppJobQueueRow;
+            if (row.kind !== 'edit') return;
+            const item = mapQueueItem(row);
+            if (ACTIVE_STATUSES.includes(item.status)) handlers.onUpdate?.(item);
+            else handlers.onDelete?.(item);
+          }
+        )
+        .on(
+          'postgres_changes',
+          { event: 'DELETE', schema: 'public', table: 'app_job_queue', filter: `app_id=eq.${appId}` },
+          (payload) => {
+            const row = payload.old as DbAppJobQueueRow;
+            if (row.kind !== 'edit') return;
+            handlers.onDelete?.(mapQueueItem(row));
+          }
+        );
+    });
   }
 }
 

package/src/data/apps/repository.ts

@@ -16,7 +16,7 @@ import type {
 import { appsRemoteDataSource } from './remote';
 import type { AppsRemoteDataSource } from './remote';
 import { BaseRepository } from '../../data/base-repository';
-import { getSupabaseClient } from '../../core/services/supabase';
+import { subscribeManagedChannel } from '../../core/services/supabase/realtimeManager';
 
 type DbAppRow = {
   id: string;
@@ -152,38 +152,33 @@ class AppsRepositoryImpl extends BaseRepository implements AppsRepository {
   }
 
   private subscribeToAppChannel(channelKey: string, filter: string, handlers: AppSubscriptionHandlers): () => void {
-    const supabase = getSupabaseClient();
-    const channel = supabase
-      .channel(channelKey)
-      .on(
-        'postgres_changes',
-        { event: 'INSERT', schema: 'public', table: 'app', filter },
-        (payload) => {
-          console.log('[subscribeToAppChannel] onInsert', payload);
-          handlers.onInsert?.(mapDbAppRow(payload.new as DbAppRow));
-        }
-      )
-      .on(
-        'postgres_changes',
-        { event: 'UPDATE', schema: 'public', table: 'app', filter },
-        (payload) => {
-          console.log('[subscribeToAppChannel] onUpdate', payload);
-          handlers.onUpdate?.(mapDbAppRow(payload.new as DbAppRow));
-        }
-      )
-      .on(
-        'postgres_changes',
-        { event: 'DELETE', schema: 'public', table: 'app', filter },
-        (payload) => {
-          console.log('[subscribeToAppChannel] onDelete', payload);
-          handlers.onDelete?.(mapDbAppRow(payload.old as DbAppRow));
-        }
-      )
-      .subscribe();
-
-    return () => {
-      supabase.removeChannel(channel);
-    };
+    return subscribeManagedChannel(channelKey, (channel) => {
+      channel
+        .on(
+          'postgres_changes',
+          { event: 'INSERT', schema: 'public', table: 'app', filter },
+          (payload) => {
+            console.log('[subscribeToAppChannel] onInsert', payload);
+            handlers.onInsert?.(mapDbAppRow(payload.new as DbAppRow));
+          }
+        )
+        .on(
+          'postgres_changes',
+          { event: 'UPDATE', schema: 'public', table: 'app', filter },
+          (payload) => {
+            console.log('[subscribeToAppChannel] onUpdate', payload);
+            handlers.onUpdate?.(mapDbAppRow(payload.new as DbAppRow));
+          }
+        )
+        .on(
+          'postgres_changes',
+          { event: 'DELETE', schema: 'public', table: 'app', filter },
+          (payload) => {
+            console.log('[subscribeToAppChannel] onDelete', payload);
+            handlers.onDelete?.(mapDbAppRow(payload.old as DbAppRow));
+          }
+        );
+    });
   }
 }
 

package/src/data/messages/repository.ts

@@ -2,7 +2,7 @@ import type { MessagesRemoteDataSource } from './remote';
 import { messagesRemoteDataSource } from './remote';
 import type { Message } from './types';
 import { BaseRepository } from '../../data/base-repository';
-import { getSupabaseClient } from '../../core/services/supabase';
+import { subscribeManagedChannel } from '../../core/services/supabase/realtimeManager';
 
 type DbMessageRow = {
   id: string;
@@ -64,38 +64,33 @@ class MessagesRepositoryImpl extends BaseRepository implements MessagesRepositor
       onDelete?: (m: Message) => void;
     }
   ): () => void {
-    const supabase = getSupabaseClient();
-    const channel = supabase
-      .channel(`messages:thread:${threadId}`)
-      .on(
-        'postgres_changes',
-        { event: 'INSERT', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
-        (payload) => {
-          const row = payload.new as DbMessageRow;
-          handlers.onInsert?.(mapDbRowToMessage(row));
-        }
-      )
-      .on(
-        'postgres_changes',
-        { event: 'UPDATE', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
-        (payload) => {
-          const row = payload.new as DbMessageRow;
-          handlers.onUpdate?.(mapDbRowToMessage(row));
-        }
-      )
-      .on(
-        'postgres_changes',
-        { event: 'DELETE', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
-        (payload) => {
-          const row = payload.old as DbMessageRow;
-          handlers.onDelete?.(mapDbRowToMessage(row));
-        }
-      )
-      .subscribe();
-
-    return () => {
-      supabase.removeChannel(channel);
-    };
+    return subscribeManagedChannel(`messages:thread:${threadId}`, (channel) => {
+      channel
+        .on(
+          'postgres_changes',
+          { event: 'INSERT', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
+          (payload) => {
+            const row = payload.new as DbMessageRow;
+            handlers.onInsert?.(mapDbRowToMessage(row));
+          }
+        )
+        .on(
+          'postgres_changes',
+          { event: 'UPDATE', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
+          (payload) => {
+            const row = payload.new as DbMessageRow;
+            handlers.onUpdate?.(mapDbRowToMessage(row));
+          }
+        )
+        .on(
+          'postgres_changes',
+          { event: 'DELETE', schema: 'public', table: 'message', filter: `thread_id=eq.${threadId}` },
+          (payload) => {
+            const row = payload.old as DbMessageRow;
+            handlers.onDelete?.(mapDbRowToMessage(row));
+          }
+        );
+    });
   }
 }