Merge branch 'master' of ssh://onedev.gitcitadel.eu:6611/Alexandria/gc-alexandria into feature/text-entry

src/lib/utils/websocket_utils.ts

@@ -22,42 +22,87 @@ export interface NostrFilter {
   limit?: number;
 }
 
+type ResolveCallback<T> = (value: T | PromiseLike<T>) => void;
+type RejectCallback = (reason?: any) => void;
+type EventHandler = (ev: Event) => void;
+type EventHandlerReject = (reject: RejectCallback) => EventHandler; 
+type EventHandlerResolve<T> = (resolve: ResolveCallback<T>) => EventHandlerReject;
+
+function handleMessage(
+  ev: MessageEvent,
+  subId: string,
+  resolve: (event: NostrEvent) => void,
+  reject: (reason: any) => void
+) {
+  const data = JSON.parse(ev.data);
+
+  if (data[1] !== subId) {
+    return;
+  }
+
+  switch (data[0]) {
+    case "EVENT":
+      break;
+    case "CLOSED":
+      reject(new Error(`[WebSocket Utils]: Subscription ${subId} closed`));
+      break;
+    case "EOSE":
+      reject(new Error(`[WebSocket Utils]: Event not found`));
+      break;
+  }
+
+  const event = data[2] as NostrEvent;
+  if (!event) {
+    return;
+  }
+
+  resolve(event);
+}
+
+function handleError(
+  ev: Event,
+  reject: (reason: any) => void
+) {
+  reject(ev);
+}
+
 export async function fetchNostrEvent(filter: NostrFilter): Promise<NostrEvent> {
   // TODO: Improve relay selection when relay management is implemented.
   const ws = await WebSocketPool.instance.acquire("wss://thecitadel.nostr1.com");
   const subId = crypto.randomUUID();
 
+  // AI-NOTE: Currying is used here to abstract the internal handler logic away from the WebSocket
+  // handling logic. The message and error handlers themselves can be refactored without affecting
+  // the WebSocket handling logic.
+  const curriedMessageHandler: (subId: string) => EventHandlerResolve<NostrEvent> =
+    (subId) =>
+      (resolve) =>
+        (reject) =>
+          (ev: MessageEvent) =>
+            handleMessage(ev, subId, resolve, reject);
+  const curriedErrorHandler: EventHandlerReject =
+    (reject) =>
+      (ev: Event) =>
+        handleError(ev, reject);
+
+  // AI-NOTE: These variables store references to partially-applied handlers so that the `finally`
+  // block receives the correct references to clean up the listeners.
+  let messageHandler: EventHandler;
+  let errorHandler: EventHandler;
+
   const res = new Promise<NostrEvent>((resolve, reject) => {
-    ws.addEventListener("message", (ev) => {
+    messageHandler = curriedMessageHandler(subId)(resolve)(reject);
-      const data = JSON.parse(ev.data);
+    errorHandler = curriedErrorHandler(reject);
-
+
-      if (data[1] !== subId) {
+    ws.addEventListener("message", messageHandler);
-        return;
+    ws.addEventListener("error", errorHandler);
-      }
+  })
-
+  .withTimeout(2000)
-      switch (data[0]) {
+  .finally(() => {
-        case "EVENT":
+    ws.removeEventListener("message", messageHandler);
-          break;
+    ws.removeEventListener("error", errorHandler);
-        case "CLOSED":
+    WebSocketPool.instance.release(ws);
-          reject(new Error(`[WebSocket Utils]: Subscription ${subId} closed`));
+  });
-          break;
-        case "EOSE":
-          reject(new Error(`[WebSocket Utils]: Event not found`));
-          break;
-      }
-
-      const event = data[2] as NostrEvent;
-      if (!event) {
-        return;
-      }
-
-      resolve(event);
-    });
-
-    ws.addEventListener("error", (ev) => {
-      reject(ev);
-    });
-  }).withTimeout(2000);
 
   ws.send(JSON.stringify(["REQ", subId, filter]));
   return res;
@@ -70,14 +115,14 @@ export async function fetchEventById(id: string): Promise<NostrEvent> {
   try {
     const event = await fetchNostrEvent({ ids: [id], limit: 1 });
     if (!event) {
-      throw error(404, `Event not found for ID: ${id}`);
+      error(404, `Event not found for ID: ${id}`);
     }
     return event;
   } catch (err) {
     if (err && typeof err === "object" && "status" in err) {
       throw err;
     }
-    throw error(404, `Failed to fetch event by ID: ${err}`);
+    error(404, `Failed to fetch event by ID: ${err}`);
   }
 }
 
@@ -88,14 +133,14 @@ export async function fetchEventByDTag(dTag: string): Promise<NostrEvent> {
   try {
     const event = await fetchNostrEvent({ "#d": [dTag], limit: 1 });
     if (!event) {
-      throw error(404, `Event not found for d-tag: ${dTag}`);
+      error(404, `Event not found for d-tag: ${dTag}`);
     }
     return event;
   } catch (err) {
     if (err && typeof err === "object" && "status" in err) {
       throw err;
     }
-    throw error(404, `Failed to fetch event by d-tag: ${err}`);
+    error(404, `Failed to fetch event by d-tag: ${err}`);
   }
 }
 
@@ -112,14 +157,14 @@ export async function fetchEventByNaddr(naddr: string): Promise<NostrEvent> {
     };
     const event = await fetchNostrEvent(filter);
     if (!event) {
-      throw error(404, `Event not found for naddr: ${naddr}`);
+      error(404, `Event not found for naddr: ${naddr}`);
     }
     return event;
   } catch (err) {
     if (err && typeof err === "object" && "status" in err) {
       throw err;
     }
-    throw error(404, `Failed to fetch event by naddr: ${err}`);
+    error(404, `Failed to fetch event by naddr: ${err}`);
   }
 }
 
@@ -131,13 +176,13 @@ export async function fetchEventByNevent(nevent: string): Promise<NostrEvent> {
     const decoded = neventDecode(nevent);
     const event = await fetchNostrEvent({ ids: [decoded.id], limit: 1 });
     if (!event) {
-      throw error(404, `Event not found for nevent: ${nevent}`);
+      error(404, `Event not found for nevent: ${nevent}`);
     }
     return event;
   } catch (err) {
     if (err && typeof err === "object" && "status" in err) {
       throw err;
     }
-    throw error(404, `Failed to fetch event by nevent: ${err}`);
+    error(404, `Failed to fetch event by nevent: ${err}`);
   }
 }

src/routes/publication/+page.server.ts

@@ -25,17 +25,17 @@ export const load: PageServerLoad = ({ url }) => {
   if (id) {
     // Check if id is an naddr or nevent
     if (id.startsWith(IDENTIFIER_PREFIXES.NADDR)) {
-      throw redirect(301, `${ROUTES.NADDR}/${id}`);
+      redirect(301, `${ROUTES.NADDR}/${id}`);
     } else if (id.startsWith(IDENTIFIER_PREFIXES.NEVENT)) {
-      throw redirect(301, `${ROUTES.NEVENT}/${id}`);
+      redirect(301, `${ROUTES.NEVENT}/${id}`);
     } else {
       // Assume it's a hex ID
-      throw redirect(301, `${ROUTES.ID}/${id}`);
+      redirect(301, `${ROUTES.ID}/${id}`);
     }
   } else if (dTag) {
-    throw redirect(301, `${ROUTES.D_TAG}/${dTag}`);
+    redirect(301, `${ROUTES.D_TAG}/${dTag}`);
   }
 
   // If no query parameters, redirect to the start page
-  throw redirect(301, ROUTES.START);
+  redirect(301, ROUTES.START);
 }; 

src/routes/publication/[type]/[identifier]/+layout.server.ts

@@ -1,23 +1,40 @@
 import { error } from "@sveltejs/kit";
 import type { LayoutServerLoad } from "./$types";
+import { fetchEventByDTag, fetchEventById, fetchEventByNaddr, fetchEventByNevent } from "../../../../lib/utils/websocket_utils.ts";
+import type { NostrEvent } from "../../../../lib/utils/websocket_utils.ts";
 
 export const load: LayoutServerLoad = async ({ params, url }) => {
   const { type, identifier } = params;
 
-  // Validate the identifier type for SSR
+  let indexEvent: NostrEvent;
-  const validTypes = ['id', 'd', 'naddr', 'nevent'];
+
-  if (!validTypes.includes(type)) {
+  // Handle different identifier types
-    throw error(400, `Unsupported identifier type: ${type}`);
+  switch (type) {
+    case 'id':
+      indexEvent = await fetchEventById(identifier);
+      break;
+    case 'd':
+      indexEvent = await fetchEventByDTag(identifier);
+      break;
+    case 'naddr':
+      indexEvent = await fetchEventByNaddr(identifier);
+      break;
+    case 'nevent':
+      indexEvent = await fetchEventByNevent(identifier);
+      break;
+    default:
+      error(400, `Unsupported identifier type: ${type}`);
   }
 
-  // Provide basic metadata for SSR - actual fetching will happen on client
+  // Extract metadata for meta tags
-  const title = "Alexandria Publication";
+  const title = indexEvent.tags.find((tag) => tag[0] === "title")?.[1] || "Alexandria Publication";
-  const summary = "Alexandria is a digital library, utilizing Nostr events for curated publications and wiki pages.";
+  const summary = indexEvent.tags.find((tag) => tag[0] === "summary")?.[1] || 
-  const image = "/screenshots/old_books.jpg";
+    "Alexandria is a digital library, utilizing Nostr events for curated publications and wiki pages.";
+  const image = indexEvent.tags.find((tag) => tag[0] === "image")?.[1] || "/screenshots/old_books.jpg";
   const currentUrl = `${url.origin}${url.pathname}`;
 
   return {
-    indexEvent: null, // Will be fetched on client side
+    indexEvent,
     metadata: {
       title,
       summary,

src/routes/publication/[type]/[identifier]/+layout.svelte

@@ -1,4 +1,5 @@
 <script lang="ts">
+  import { browser } from "$app/environment";
   import type { LayoutProps } from "./$types";
 
   let { data, children }: LayoutProps = $props();
@@ -26,4 +27,6 @@
   <meta name="twitter:image" content={metadata.image} />
 </svelte:head>
 
-{@render children()} 
+{#if browser}
+  {@render children()}
+{/if}

src/routes/publication/[type]/[identifier]/+layout.ts

@@ -1,65 +1 @@
-import { error } from "@sveltejs/kit";
+export const ssr = true;
-import type { LayoutLoad } from "./$types";
-import { fetchEventByDTag, fetchEventById, fetchEventByNaddr, fetchEventByNevent } from "../../../../lib/utils/websocket_utils.ts";
-import type { NostrEvent } from "../../../../lib/utils/websocket_utils.ts";
-import { browser } from "$app/environment";
-
-export const load: LayoutLoad = async ({ params, url }) => {
-  const { type, identifier } = params;
-
-  // Only fetch on the client side where WebSocket is available
-  if (!browser) {
-    // Return basic metadata for SSR
-    return {
-      indexEvent: null,
-      metadata: {
-        title: "Alexandria Publication",
-        summary: "Alexandria is a digital library, utilizing Nostr events for curated publications and wiki pages.",
-        image: "/screenshots/old_books.jpg",
-        currentUrl: `${url.origin}${url.pathname}`,
-      },
-    };
-  }
-
-  let indexEvent: NostrEvent;
-
-  try {
-    // Handle different identifier types
-    switch (type) {
-      case 'id':
-        indexEvent = await fetchEventById(identifier);
-        break;
-      case 'd':
-        indexEvent = await fetchEventByDTag(identifier);
-        break;
-      case 'naddr':
-        indexEvent = await fetchEventByNaddr(identifier);
-        break;
-      case 'nevent':
-        indexEvent = await fetchEventByNevent(identifier);
-        break;
-      default:
-        throw error(400, `Unsupported identifier type: ${type}`);
-    }
-
-    // Extract metadata for meta tags
-    const title = indexEvent.tags.find((tag) => tag[0] === "title")?.[1] || "Alexandria Publication";
-    const summary = indexEvent.tags.find((tag) => tag[0] === "summary")?.[1] || 
-      "Alexandria is a digital library, utilizing Nostr events for curated publications and wiki pages.";
-    const image = indexEvent.tags.find((tag) => tag[0] === "image")?.[1] || "/screenshots/old_books.jpg";
-    const currentUrl = `${url.origin}${url.pathname}`;
-
-    return {
-      indexEvent,
-      metadata: {
-        title,
-        summary,
-        image,
-        currentUrl,
-      },
-    };
-  } catch (err) {
-    console.error('Failed to fetch publication:', err);
-    throw error(404, `Failed to load publication: ${err}`);
-  }
-};

src/routes/publication/[type]/[identifier]/+page.server.ts

@@ -1,18 +0,0 @@
-import { error } from "@sveltejs/kit";
-import type { PageServerLoad } from "./$types";
-
-export const load: PageServerLoad = async ({ params }) => {
-  const { type, identifier } = params;
-
-  // Validate the identifier type for SSR
-  const validTypes = ['id', 'd', 'naddr', 'nevent'];
-  if (!validTypes.includes(type)) {
-    throw error(400, `Unsupported identifier type: ${type}`);
-  }
-
-  // Provide basic data for SSR - actual fetching will happen on client
-  return {
-    publicationType: "", // Will be determined on client side
-    indexEvent: null, // Will be fetched on client side
-  };
-}; 

src/routes/publication/[type]/[identifier]/+page.ts

@@ -2,53 +2,38 @@ import { error } from "@sveltejs/kit";
 import type { PageLoad } from "./$types";
 import { fetchEventByDTag, fetchEventById, fetchEventByNaddr, fetchEventByNevent } from "../../../../lib/utils/websocket_utils.ts";
 import type { NostrEvent } from "../../../../lib/utils/websocket_utils.ts";
-import { browser } from "$app/environment";
 
 export const load: PageLoad = async ({ params }: { params: { type: string; identifier: string } }) => {
   const { type, identifier } = params;
 
-  // Only fetch on the client side where WebSocket is available
+  let indexEvent: NostrEvent | null;
-  if (!browser) {
-    // Return basic data for SSR
-    return {
-      publicationType: "",
-      indexEvent: null,
-    };
-  }
-
-  let indexEvent: NostrEvent;
 
-  try {
+  // Handle different identifier types
-    // Handle different identifier types
+  switch (type) {
-    switch (type) {
+    case 'id':
-      case 'id':
+      indexEvent = await fetchEventById(identifier);
-        indexEvent = await fetchEventById(identifier);
+      break;
-        break;
+    case 'd':
-      case 'd':
+      indexEvent = await fetchEventByDTag(identifier);
-        indexEvent = await fetchEventByDTag(identifier);
+      break;
-        break;
+    case 'naddr':
-      case 'naddr':
+      indexEvent = await fetchEventByNaddr(identifier);
-        indexEvent = await fetchEventByNaddr(identifier);
+      break;
-        break;
+    case 'nevent':
-      case 'nevent':
+      indexEvent = await fetchEventByNevent(identifier);
-        indexEvent = await fetchEventByNevent(identifier);
+      break;
-        break;
+    default:
-      default:
+      error(400, `Unsupported identifier type: ${type}`);
-        throw error(400, `Unsupported identifier type: ${type}`);
+  }
-    }
 
-    if (!indexEvent) {
+  if (!indexEvent) {
-      throw error(404, `Event not found for ${type}: ${identifier}`);
+    error(404, `Event not found for ${type}: ${identifier}`);
-    }
+  }
 
-    const publicationType = indexEvent.tags.find((tag) => tag[0] === "type")?.[1] ?? "";
+  const publicationType = indexEvent.tags.find((tag) => tag[0] === "type")?.[1] ?? "";
 
-    return {
+  return {
-      publicationType,
+    publicationType,
-      indexEvent,
+    indexEvent,
-    };
+  };
-  } catch (err) {
-    console.error('Failed to fetch publication:', err);
-    throw error(404, `Failed to load publication: ${err}`);
-  }
 };