Update subscription function signatures

Author: backspace

packages/base/cards-grid.gts

@@ -45,6 +45,8 @@ import Captions from '@cardstack/boxel-icons/captions';
 import CardsIcon from '@cardstack/boxel-icons/cards';
 import { registerDestructor } from '@ember/destroyable';
 
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
+
 type IconComponent = typeof Captions;
 interface SortOption {
   displayName: string;
@@ -469,9 +471,8 @@ class Isolated extends Component<typeof CardsGrid> {
       ) ?? this.filters[0];
   });
 
-  private refreshFilterList = (ev: MessageEvent) => {
-    let data = JSON.parse(ev.data);
-    if (ev.type === 'index' && data.type === 'incremental') {
+  private refreshFilterList = (ev: RealmEventEventContent) => {
+    if (ev.eventName === 'index' && ev.indexType === 'incremental') {
       this.loadFilterList.perform();
     }
   };

packages/host/app/components/prerendered-card-search.gts

@@ -26,6 +26,8 @@ import { type HTMLComponent, htmlComponent } from '../lib/html-component';
 import type CardService from '../services/card-service';
 import type LoaderService from '../services/loader-service';
 
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
+
 const waiter = buildWaiter('prerendered-card-search:waiter');
 
 export interface PrerenderedCardData {
@@ -252,8 +254,11 @@ export default class PrerenderedCardSearch extends Component<Signature> {
     }
   }
 
-  private markRealmNeedsRefreshing = (ev: MessageEvent, realm: string) => {
-    if (ev.type === 'index') {
+  private markRealmNeedsRefreshing = (
+    ev: RealmEventEventContent,
+    realm: string,
+  ) => {
+    if (ev.eventName === 'index') {
       this.realmsNeedingRefresh.add(realm);
     }
   };

packages/host/app/helpers/subscribe-to-realms.ts

@@ -4,11 +4,13 @@ import { isEqual } from 'lodash';
 
 import { subscribeToRealm } from '@cardstack/runtime-common';
 
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
+
 interface Signature {
   Args: {
     Positional: [
       realms: string[],
-      callback: (ev: MessageEvent, realmURL: string) => void,
+      callback: (ev: RealmEventEventContent, realmURL: string) => void,
     ];
   };
   Return: void;

packages/host/app/resources/directory.ts

@@ -16,6 +16,8 @@ import type LoaderService from '../services/loader-service';
 import type MessageService from '../services/message-service';
 import type NetworkService from '../services/network';
 
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
+
 const log = logger('resource:directory');
 
 interface Args {
@@ -65,16 +67,16 @@ export class DirectoryResource extends Resource<Args> {
         url: realmURL.href,
         unsubscribe: this.messageService.subscribe(
           realmURL.href,
-          ({ type, data: dataStr }) => {
+          (event: RealmEventEventContent) => {
             if (!this.directoryURL) {
               return;
             }
-            let eventData = JSON.parse(dataStr);
-            if (type !== 'index' || !eventData.updatedFile) {
+
+            if (event.eventName !== 'index' || !event.updatedFile) {
               return;
             }
 
-            let { updatedFile } = eventData as { updatedFile: string };
+            let { updatedFile } = event as { updatedFile: string };
             let segments = updatedFile.split('/');
             segments.pop();
             let updatedDir = segments.join('/').replace(/([^/])$/, '$1/'); // directories always end in '/'

packages/host/app/resources/file.ts

@@ -19,6 +19,8 @@ import type LoaderService from '../services/loader-service';
 import type MessageService from '../services/message-service';
 import type NetworkService from '../services/network';
 
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
+
 const log = logger('resource:file');
 const utf8 = new TextDecoder();
 const encoder = new TextEncoder();
@@ -91,7 +93,7 @@ class _FileResource extends Resource<Args> {
 
   private setSubscription(
     realmURL: string,
-    callback: (ev: { type: string; data: string }) => void,
+    callback: (ev: RealmEventEventContent) => void,
   ) {
     if (this.subscription && this.subscription.url !== realmURL) {
       this.subscription.unsubscribe();
@@ -197,19 +199,18 @@ class _FileResource extends Resource<Args> {
       },
     });
 
-    this.setSubscription(realmURL, (event: { type: string; data: string }) => {
-      let eventData = JSON.parse(event.data);
+    this.setSubscription(realmURL, (event: RealmEventEventContent) => {
       if (
-        event.type !== 'index' ||
+        event.eventName !== 'index' ||
         // we wait specifically for the index complete event ("incremental") so
         // that the subsequent index read retrieves the latest contents of the file
-        eventData.type !== 'incremental' ||
-        !Array.isArray(eventData.invalidations)
+        event.indexType !== 'incremental' ||
+        !Array.isArray(event.invalidations)
       ) {
         return;
       }
 
-      let { invalidations } = eventData as { invalidations: string[] };
+      let { invalidations } = event as { invalidations: string[] };
       let normalizedURL = this.url.endsWith('.json')
         ? this.url.replace(/\.json$/, '')
         : this.url;

packages/host/app/resources/search.ts

@@ -27,6 +27,7 @@ import { type CardResource, getCard } from './card-resource';
 
 import type CardService from '../services/card-service';
 import type RealmServerService from '../services/realm-server';
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
 
 const waiter = buildWaiter('search-resource:search-waiter');
 
@@ -66,13 +67,15 @@ export class Search extends Resource<Args> {
         url: `${realm}_message`,
         unsubscribe: subscribeToRealm(
           realm,
-          ({ type, data }: { type: string; data: string }) => {
+          (event: RealmEventEventContent) => {
             if (query === undefined) {
               return;
             }
-            let eventData = JSON.parse(data);
             // we are only interested in incremental index events
-            if (type !== 'index' || eventData.type !== 'incremental') {
+            if (
+              event.eventName !== 'index' ||
+              event.indexType !== 'incremental'
+            ) {
               return;
             }
             this.search.perform(query);

packages/host/app/services/matrix-service.ts

@@ -46,6 +46,7 @@ import {
   APP_BOXEL_COMMAND_RESULT_WITH_NO_OUTPUT_MSGTYPE,
   APP_BOXEL_COMMAND_RESULT_WITH_OUTPUT_MSGTYPE,
   APP_BOXEL_MESSAGE_MSGTYPE,
+  APP_BOXEL_REALM_EVENT_EVENT_TYPE,
   APP_BOXEL_REALM_SERVER_EVENT_MSGTYPE,
   APP_BOXEL_REALMS_EVENT_TYPE,
   APP_BOXEL_ACTIVE_LLM,
@@ -1353,22 +1354,19 @@ export default class MatrixService extends Service {
     ) {
       await this.realmServer.handleEvent(event);
     } else if (
-      event.type === 'm.room.message' &&
-      event.content?.msgtype === 'app.boxel.sse' &&
+      event.type === APP_BOXEL_REALM_EVENT_EVENT_TYPE &&
       event.sender
     ) {
       // FIXME provenance should be checked
       console.log('received sse event', event);
-      let parsedEventContent = JSON.parse(event.content.body);
-      console.log('relayMatrixSSE', parsedEventContent);
 
       let realmInfoForSender = this.realm.realmOfMatrixUsername(event.sender);
       if (!realmInfoForSender) {
         console.log('ignoring sse event because no realm found', event);
       } else {
         this.messageService.relayMatrixSSE(
           realmInfoForSender.url,
-          parsedEventContent,
+          event.content,
         );
       }
     }

packages/host/app/services/message-service.ts

@@ -12,17 +12,24 @@ import { SessionLocalStorageKey } from '../utils/local-storage-keys';
 
 import type NetworkService from './network';
 
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
+
 export default class MessageService extends Service {
   @tracked subscriptions: Map<string, EventSource> = new Map();
-  @tracked listenerCallbacks: Map<string, ((ev: MessageEvent) => void)[]> =
-    new Map();
-  @service private declare network: NetworkService;
+  @tracked listenerCallbacks: Map<
+    string,
+    ((ev: RealmEventEventContent) => void)[]
+  > = new Map();
+  @service declare private network: NetworkService;
 
   register() {
     (globalThis as any)._CARDSTACK_REALM_SUBSCRIBE = this;
   }
 
-  subscribe(realmURL: string, cb: (ev: MessageEvent) => void): () => void {
+  subscribe(
+    realmURL: string,
+    cb: (ev: RealmEventEventContent) => void,
+  ): () => void {
     console.log('subscribe', realmURL, cb);
     if (isTesting()) {
       // only use Matrix-y callbacks in testing
@@ -66,14 +73,10 @@ export default class MessageService extends Service {
     };
   }
 
-  relayMatrixSSE(realmURL: string, event: any) {
+  relayMatrixSSE(realmURL: string, event: RealmEventEventContent) {
     console.log('relaying matrix sse event', realmURL, event);
     this.listenerCallbacks.get(realmURL)?.forEach((cb) => {
-      let eventWithStringData = {
-        type: event.type,
-        data: JSON.stringify(event.data),
-      } as MessageEvent;
-      cb(eventWithStringData);
+      cb(event);
     });
   }
 }

packages/host/app/services/realm.ts

@@ -41,6 +41,10 @@ import type MessageService from './message-service';
 import type NetworkService from './network';
 import type RealmServerService from './realm-server';
 import type ResetService from './reset';
+import type {
+  IndexRealmEventContent,
+  RealmEventEventContent,
+} from '@cardstack/base/matrix-event';
 
 const log = logger('service:realm');
 
@@ -151,21 +155,21 @@ class RealmResource {
     this.subscription = {
       unsubscribe: this.messageService.subscribe(
         this.realmURL,
-        ({ type, data: dataStr }: { type: string; data: string }) => {
+        (event: RealmEventEventContent) => {
           if (!this.info) {
             console.warn(
               `No realm info exists for ${this.realmURL} when trying to set indexing status`,
             );
             return;
           }
-          if (type !== 'index') {
+          if (event.eventName !== 'index') {
             return;
           }
-          let data = JSON.parse(dataStr) as IndexEventData;
-          if (data.type === 'full') {
+          let data = event as IndexRealmEventContent;
+          if (data.indexType === 'full') {
             return;
           }
-          switch (data.type) {
+          switch (data.indexType) {
             case 'incremental-index-initiation':
               this.info.isIndexing = true;
               break;

packages/host/app/services/store.ts

@@ -30,6 +30,8 @@ import type RealmService from './realm';
 
 import type { CardResource } from '../resources/card-resource';
 
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
+
 class ResettableIdentityContext implements IdentityContext {
   #cards = new Map<
     string,
@@ -227,15 +229,15 @@ export default class StoreService extends Service {
     return { url, card, error };
   }
 
-  private handleInvalidations = ({ type, data: dataStr }: MessageEvent) => {
-    if (type !== 'index') {
+  private handleInvalidations = (event: RealmEventEventContent) => {
+    if (event.eventName !== 'index') {
       return;
     }
-    let data = JSON.parse(dataStr);
-    if (data.type !== 'incremental') {
+
+    if (event.indexType !== 'incremental') {
       return;
     }
-    let invalidations = data.invalidations as string[];
+    let invalidations = event.invalidations as string[];
 
     if (invalidations.find((i) => hasExecutableExtension(i))) {
       // the invalidation included code changes too. in this case we
@@ -259,7 +261,7 @@ export default class StoreService extends Service {
           // Do not reload if the event is a result of a request that we made. Otherwise we risk overwriting
           // the inputs with past values. This can happen if the user makes edits in the time between the auto
           // save request and the arrival SSE event.
-          if (!this.cardService.clientRequestIds.has(data.clientRequestId)) {
+          if (!this.cardService.clientRequestIds.has(event.clientRequestId)) {
             this.reload.perform(liveCard);
           }
         } else if (!this.identityContext.get(invalidation)) {

packages/runtime-common/index.ts

@@ -1,5 +1,7 @@
 import { CardResource } from './card-document';
 
+import type { RealmEventEventContent } from '@cardstack/base/matrix-event';
+
 // a card resource but with optional "id" and "type" props
 export type LooseCardResource = Omit<CardResource, 'id' | 'type'> & {
   type?: 'card';
@@ -322,12 +324,15 @@ export async function createNewCard<T extends CardDef>(
 }
 
 export interface RealmSubscribe {
-  subscribe(realmURL: string, cb: (ev: MessageEvent) => void): () => void;
+  subscribe(
+    realmURL: string,
+    cb: (ev: RealmEventEventContent) => void,
+  ): () => void;
 }
 
 export function subscribeToRealm(
   realmURL: string,
-  cb: (ev: MessageEvent) => void,
+  cb: (ev: RealmEventEventContent) => void,
 ): () => void {
   let here = globalThis as any;
   if (!here._CARDSTACK_REALM_SUBSCRIBE) {