hardcoded-config

src/context/connect.tsx

@@ -3,9 +3,10 @@ import type { Accessor, JSX } from 'solid-js'
 import type { Author, Reaction, Shout, Topic } from '../graphql/schema/core.gen'
 
 import { EventStreamContentType, fetchEventSource } from '@microsoft/fetch-event-source'
-import { createContext, createEffect, createSignal, useContext } from 'solid-js'
+import { createContext, createEffect, createSignal, on, useContext } from 'solid-js'
 
 import { Chat, Message } from '../graphql/schema/chat.gen'
+import { sseUrl } from '../utils/config'
 import { useSession } from './session'
 
 const RECONNECT_TIMES = 2
@@ -38,51 +39,59 @@ export const ConnectProvider = (props: { children: JSX.Element }) => {
     setHandlers((hhh) => [...hhh, handler])
   }
 
-  createEffect(async () => {
+  createEffect(
-    const token = session()?.access_token
+    on(
-    if (token && !connected() && retried() <= RECONNECT_TIMES) {
+      () => session()?.access_token,
-      console.info('[context.connect] init SSE connection')
+      async ([tkn]) => {
-      try {
+        if (!sseUrl) return
-        await fetchEventSource('https://connect.discours.io', {
+        if (!tkn) return
-          method: 'GET',
+        if (!connected() && retried() <= RECONNECT_TIMES) {
-          headers: {
+          console.info('[context.connect] got token, init SSE connection')
-            'Content-Type': 'application/json',
+          try {
-            Authorization: token,
+            await fetchEventSource(sseUrl, {
-          },
+              method: 'GET',
-          onmessage(event) {
+              headers: {
-            const m: SSEMessage = JSON.parse(event.data || '{}')
+                'Content-Type': 'application/json',
-            console.log('[context.connect] Received message:', m)
+                Authorization: tkn,
-            messageHandlers().forEach((handler) => handler(m))
+              },
-          },
+              onmessage(event) {
-          onopen: (response) => {
+                const m: SSEMessage = JSON.parse(event.data || '{}')
-            console.log('[context.connect] SSE connection opened', response)
+                console.log('[context.connect] Received message:', m)
-            if (response.ok && response.headers.get('content-type') === EventStreamContentType) {
+                messageHandlers().forEach((handler) => handler(m))
-              setConnected(true)
+              },
-              setRetried(0)
+              onopen: (response) => {
-              return Promise.resolve()
+                console.log('[context.connect] SSE connection opened', response)
-            }
+                if (response.ok && response.headers.get('content-type') === EventStreamContentType) {
-            return Promise.reject(`SSE: cannot connect to real-time updates, status: ${response.status}`)
+                  setConnected(true)
-          },
+                  setRetried(0)
-          onclose() {
+                  return Promise.resolve()
-            console.log('[context.connect] SSE connection closed by server')
+                }
-            setConnected(false)
+                return Promise.reject(
-            if (retried() < RECONNECT_TIMES) {
+                  `SSE: cannot connect to real-time updates, status: ${response.status}`,
-              setRetried((r) => r + 1)
+                )
-            }
+              },
-          },
+              onclose() {
-          onerror(err) {
+                console.log('[context.connect] SSE connection closed by server')
-            console.error('[context.connect] SSE connection error:', err)
+                setConnected(false)
-            setConnected(false)
+                if (retried() < RECONNECT_TIMES) {
-            if (retried() < RECONNECT_TIMES) {
+                  setRetried((r) => r + 1)
-              setRetried((r) => r + 1)
+                }
-            } else throw Error(err)
+              },
-          },
+              onerror(err) {
-        })
+                console.error('[context.connect] SSE connection error:', err)
-      } catch (error) {
+                setConnected(false)
-        console.error('[context.connect] SSE connection failed:', error)
+                if (retried() < RECONNECT_TIMES) {
-      }
+                  setRetried((r) => r + 1)
-    }
+                } else throw Error(err)
-  })
+              },
+            })
+          } catch (error) {
+            console.error('[context.connect] SSE connection failed:', error)
+          }
+        }
+      },
+    ),
+  )
 
   const value: ConnectContextType = { addHandler, connected }
 

src/renderer/_default.page.client.tsx

@@ -9,7 +9,7 @@ import { hydrate } from 'solid-js/web'
 
 import { App } from '../components/App'
 import { initRouter } from '../stores/router'
-import { GLITCHTIP_DSN } from '../utils/config'
+import { errorsReportingDsn } from '../utils/config'
 import { resolveHydrationPromise } from '../utils/hydrationPromise'
 
 let layoutReady = false
@@ -22,7 +22,7 @@ export const render = async (pageContext: PageContextBuiltInClientWithClientRout
   initRouter(pathname, searchParams)
 
   SentryInit({
-    dsn: GLITCHTIP_DSN,
+    dsn: errorsReportingDsn,
     tracesSampleRate: 0.01,
     integrations: [replayIntegration()],
     // Session Replay

src/utils/config.ts

@@ -1,17 +1,8 @@
 export const isDev = import.meta.env.MODE === 'development'
-
-const defaultThumborUrl = 'https://images.discours.io'
 export const cdnUrl = 'https://cdn.discours.io'
-export const thumborUrl = import.meta.env.PUBLIC_THUMBOR_URL || defaultThumborUrl
+export const thumborUrl = import.meta.env.PUBLIC_THUMBOR_URL || 'https://images.discours.io'
-
+export const errorsReportingDsn = import.meta.env.PUBLIC_GLITCHTIP_DSN || import.meta.env.PUBLIC_SENTRY_DSN || ''
-export const SENTRY_DSN = import.meta.env.PUBLIC_SENTRY_DSN || ''
+export const coreApiUrl = 'https://coretest.discours.io'
-export const GLITCHTIP_DSN = import.meta.env.PUBLIC_GLITCHTIP_DSN || ''
+export const chatApiUrl = 'https://inboxtest.discours.io'
-
+export const authApiUrl = 'https://authtest.discours.io'
-const defaultCoreUrl = 'https://coretest.discours.io'
+export const sseUrl = 'https://presencetest.discours.io'
-export const coreApiUrl = import.meta.env.PUBLIC_CORE_API || defaultCoreUrl
-
-const defaultChatUrl = 'https://inboxtest.discours.io'
-export const chatApiUrl = import.meta.env.PUBLIC_CHAT_API || defaultChatUrl
-
-const defaultAuthUrl = 'https://authtest.discours.io'
-export const authApiUrl = import.meta.env.PUBLIC_AUTH_API || defaultAuthUrl