@graffiti-garden/implementation-decentralized 0.0.3 → 0.0.4

package/dist/cjs/3-protocol/4-graffiti.js

@@ -87,6 +87,7 @@ const MESSAGE_LABEL_UNLABELED = 0;
 const MESSAGE_LABEL_VALID = 1;
 const MESSAGE_LABEL_TRASH = 2;
 const MESSAGE_LABEL_INVALID = 3;
+const CONCURRENCY = 16;
 class GraffitiDecentralized {
   dids = new import_dids.DecentralizedIdentifiers();
   authorization = new import_authorization.Authorization();
@@ -597,14 +598,14 @@ class GraffitiDecentralized {
       cursor: JSON.stringify({
         channels,
         cursors
-      }),
-      continue: (session2) => this.discoverMeta(channels, schema, cursors, session2)
+      })
     };
   }
   discover = (...args) => {
     const [channels, schema, session] = args;
     return this.discoverMeta(channels, schema, {}, session);
   };
+  // @ts-ignore
   continueDiscover = (...args) => {
     const [cursor, session] = args;
     let channels;
@@ -751,62 +752,160 @@ class GraffitiDecentralized {
       queryArguments.cursor,
       inboxToken
     );
+    const inFlight = [];
+    let doneValue = null;
     while (true) {
-      const itResult = await iterator.next();
-      if (itResult.done) return itResult.value;
-      const result = itResult.value;
-      const label = result.l;
-      if (label !== MESSAGE_LABEL_VALID && label !== MESSAGE_LABEL_UNLABELED && label !== MESSAGE_LABEL_TRASH)
-        continue;
-      const messageId = result.id;
-      const { o: object, m: metadataBytes, t: receivedTags } = result.m;
-      let metadata;
-      try {
-        const metadataRaw = (0, import_dag_cbor.decode)(metadataBytes);
-        metadata = MessageMetadataSchema.parse(metadataRaw);
-      } catch (e) {
-        this.inboxes.label(
+      while (doneValue === null && inFlight.length < CONCURRENCY) {
+        const itResult = await iterator.next();
+        if (itResult.done) {
+          doneValue = itResult.value;
+          break;
+        }
+        const processPromise = this.processOneLabeledMessage(
           inboxEndpoint,
-          messageId,
-          MESSAGE_LABEL_INVALID,
-          inboxToken
-        );
-        continue;
+          itResult.value,
+          inboxToken,
+          recipient
+        ).catch((e) => {
+          throw e;
+        });
+        inFlight.push(processPromise);
       }
-      const {
-        [MESSAGE_DATA_STORAGE_BUCKET_KEY]: storageBucketKey,
-        [MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY]: tombstonedMessageId
-      } = metadata;
-      const allowedTickets = MESSAGE_DATA_ALLOWED_TICKETS_KEY in metadata ? metadata[MESSAGE_DATA_ALLOWED_TICKETS_KEY] : void 0;
-      const announcements = MESSAGE_DATA_ANNOUNCEMENTS_KEY in metadata ? metadata[MESSAGE_DATA_ANNOUNCEMENTS_KEY] : void 0;
-      if (label === MESSAGE_LABEL_VALID) {
-        yield {
-          messageId,
-          object,
-          storageBucketKey,
-          allowedTickets,
-          tags: receivedTags,
-          announcements
-        };
-        continue;
-      } else if (label === MESSAGE_LABEL_TRASH) {
-        if (!tombstonedMessageId) continue;
-        const past = await this.inboxes.get(
+      const nextProcessedPromise = inFlight.shift();
+      if (!nextProcessedPromise) {
+        if (doneValue !== null) return doneValue;
+        throw new Error("Process queue empty but no return value");
+      }
+      const processed = await nextProcessedPromise;
+      if (processed) yield processed;
+    }
+  }
+  async processOneLabeledMessage(inboxEndpoint, result, inboxToken, recipient) {
+    const label = result.l;
+    if (label !== MESSAGE_LABEL_VALID && label !== MESSAGE_LABEL_UNLABELED && label !== MESSAGE_LABEL_TRASH)
+      return;
+    const messageId = result.id;
+    const { o: object, m: metadataBytes, t: receivedTags } = result.m;
+    let metadata;
+    try {
+      const metadataRaw = (0, import_dag_cbor.decode)(metadataBytes);
+      metadata = MessageMetadataSchema.parse(metadataRaw);
+    } catch (e) {
+      this.inboxes.label(
+        inboxEndpoint,
+        messageId,
+        MESSAGE_LABEL_INVALID,
+        inboxToken
+      );
+      return;
+    }
+    const {
+      [MESSAGE_DATA_STORAGE_BUCKET_KEY]: storageBucketKey,
+      [MESSAGE_DATA_TOMBSTONED_MESSAGE_ID_KEY]: tombstonedMessageId
+    } = metadata;
+    const allowedTickets = MESSAGE_DATA_ALLOWED_TICKETS_KEY in metadata ? metadata[MESSAGE_DATA_ALLOWED_TICKETS_KEY] : void 0;
+    const announcements = MESSAGE_DATA_ANNOUNCEMENTS_KEY in metadata ? metadata[MESSAGE_DATA_ANNOUNCEMENTS_KEY] : void 0;
+    if (label === MESSAGE_LABEL_VALID) {
+      return {
+        messageId,
+        object,
+        storageBucketKey,
+        allowedTickets,
+        tags: receivedTags,
+        announcements
+      };
+    } else if (label === MESSAGE_LABEL_TRASH) {
+      if (!tombstonedMessageId) return;
+      const past = await this.inboxes.get(
+        inboxEndpoint,
+        tombstonedMessageId,
+        inboxToken
+      );
+      if (!past || past[import_inboxes.LABELED_MESSAGE_MESSAGE_KEY][import_inboxes.MESSAGE_OBJECT_KEY].url !== object.url)
+        return;
+      if (past[import_inboxes.LABELED_MESSAGE_LABEL_KEY] !== MESSAGE_LABEL_TRASH) {
+        this.inboxes.label(
           inboxEndpoint,
           tombstonedMessageId,
+          MESSAGE_LABEL_TRASH,
           inboxToken
         );
-        if (!past || past[import_inboxes.LABELED_MESSAGE_MESSAGE_KEY][import_inboxes.MESSAGE_OBJECT_KEY].url !== object.url)
-          continue;
-        if (past[import_inboxes.LABELED_MESSAGE_LABEL_KEY] !== MESSAGE_LABEL_TRASH) {
+      }
+      return {
+        messageId,
+        tombstone: true,
+        object,
+        storageBucketKey,
+        allowedTickets,
+        tags: receivedTags,
+        announcements
+      };
+    }
+    let validationError = void 0;
+    try {
+      const actor = object.actor;
+      const actorDocument = await this.dids.resolve(actor);
+      const storageBucketService = actorDocument?.service?.find(
+        (service) => service.id === import_sessions.DID_SERVICE_ID_GRAFFITI_STORAGE_BUCKET && service.type === import_sessions.DID_SERVICE_TYPE_GRAFFITI_STORAGE_BUCKET
+      );
+      if (!storageBucketService) {
+        throw new import_api.GraffitiErrorNotFound(
+          `Actor ${actor} has no storage bucket service`
+        );
+      }
+      if (typeof storageBucketService.serviceEndpoint !== "string") {
+        throw new import_api.GraffitiErrorNotFound(
+          `Actor ${actor} does not have a valid storage bucket endpoint`
+        );
+      }
+      const storageBucketEndpoint = storageBucketService.serviceEndpoint;
+      const objectBytes = await this.storageBuckets.get(
+        storageBucketEndpoint,
+        storageBucketKey,
+        import_object_encoding.MAX_OBJECT_SIZE_BYTES
+      );
+      if (MESSAGE_DATA_ALLOWED_TICKET_KEY in metadata && !recipient) {
+        throw new import_api.GraffitiErrorForbidden(
+          `Recipient is required when allowed ticket is present`
+        );
+      }
+      const privateObjectInfo = allowedTickets ? { allowedTickets } : MESSAGE_DATA_ALLOWED_TICKET_KEY in metadata ? {
+        recipient: recipient ?? "null",
+        allowedTicket: metadata[MESSAGE_DATA_ALLOWED_TICKET_KEY],
+        allowedIndex: metadata[MESSAGE_DATA_ALLOWED_TICKET_INDEX_KEY]
+      } : void 0;
+      await this.objectEncoding.validate(
+        object,
+        receivedTags,
+        objectBytes,
+        privateObjectInfo
+      );
+    } catch (e) {
+      validationError = e;
+    }
+    if (tombstonedMessageId) {
+      if (validationError instanceof import_api.GraffitiErrorNotFound) {
+        this.inboxes.get(inboxEndpoint, tombstonedMessageId, inboxToken).then((result2) => {
+          if (
+            // Make sure that it actually references the object being deleted
+            result2 && result2[import_inboxes.LABELED_MESSAGE_MESSAGE_KEY][import_inboxes.MESSAGE_OBJECT_KEY].url === object.url && // And that the object is not already marked as trash
+            result2[import_inboxes.LABELED_MESSAGE_LABEL_KEY] !== MESSAGE_LABEL_TRASH
+          ) {
+            this.inboxes.label(
+              inboxEndpoint,
+              tombstonedMessageId,
+              MESSAGE_LABEL_TRASH,
+              inboxToken
+            );
+          }
           this.inboxes.label(
             inboxEndpoint,
-            tombstonedMessageId,
+            messageId,
             MESSAGE_LABEL_TRASH,
             inboxToken
           );
-        }
-        yield {
+        });
+        return {
           messageId,
           tombstone: true,
           object,
@@ -815,117 +914,48 @@ class GraffitiDecentralized {
           tags: receivedTags,
           announcements
         };
-        continue;
-      }
-      let validationError = void 0;
-      try {
-        const actor = object.actor;
-        const actorDocument = await this.dids.resolve(actor);
-        const storageBucketService = actorDocument?.service?.find(
-          (service) => service.id === import_sessions.DID_SERVICE_ID_GRAFFITI_STORAGE_BUCKET && service.type === import_sessions.DID_SERVICE_TYPE_GRAFFITI_STORAGE_BUCKET
+      } else {
+        console.error("Recieved an incorrect tombstone object");
+        console.error(validationError);
+        this.inboxes.label(
+          inboxEndpoint,
+          messageId,
+          MESSAGE_LABEL_INVALID,
+          inboxToken
         );
-        if (!storageBucketService) {
-          throw new import_api.GraffitiErrorNotFound(
-            `Actor ${actor} has no storage bucket service`
-          );
-        }
-        if (typeof storageBucketService.serviceEndpoint !== "string") {
-          throw new import_api.GraffitiErrorNotFound(
-            `Actor ${actor} does not have a valid storage bucket endpoint`
-          );
-        }
-        const storageBucketEndpoint = storageBucketService.serviceEndpoint;
-        const objectBytes = await this.storageBuckets.get(
-          storageBucketEndpoint,
-          storageBucketKey,
-          import_object_encoding.MAX_OBJECT_SIZE_BYTES
+      }
+    } else {
+      if (validationError === void 0) {
+        this.inboxes.label(
+          inboxEndpoint,
+          messageId,
+          MESSAGE_LABEL_VALID,
+          inboxToken
         );
-        if (MESSAGE_DATA_ALLOWED_TICKET_KEY in metadata && !recipient) {
-          throw new import_api.GraffitiErrorForbidden(
-            `Recipient is required when allowed ticket is present`
-          );
-        }
-        const privateObjectInfo = allowedTickets ? { allowedTickets } : MESSAGE_DATA_ALLOWED_TICKET_KEY in metadata ? {
-          recipient: recipient ?? "null",
-          allowedTicket: metadata[MESSAGE_DATA_ALLOWED_TICKET_KEY],
-          allowedIndex: metadata[MESSAGE_DATA_ALLOWED_TICKET_INDEX_KEY]
-        } : void 0;
-        await this.objectEncoding.validate(
+        return {
+          messageId,
           object,
-          receivedTags,
-          objectBytes,
-          privateObjectInfo
+          storageBucketKey,
+          tags: receivedTags,
+          allowedTickets,
+          announcements
+        };
+      } else if (validationError instanceof import_api.GraffitiErrorNotFound) {
+        this.inboxes.label(
+          inboxEndpoint,
+          messageId,
+          MESSAGE_LABEL_TRASH,
+          inboxToken
         );
-      } catch (e) {
-        validationError = e;
-      }
-      if (tombstonedMessageId) {
-        if (validationError instanceof import_api.GraffitiErrorNotFound) {
-          this.inboxes.get(inboxEndpoint, tombstonedMessageId, inboxToken).then((result2) => {
-            if (
-              // Make sure that it actually references the object being deleted
-              result2 && result2[import_inboxes.LABELED_MESSAGE_MESSAGE_KEY][import_inboxes.MESSAGE_OBJECT_KEY].url === object.url && // And that the object is not already marked as trash
-              result2[import_inboxes.LABELED_MESSAGE_LABEL_KEY] !== MESSAGE_LABEL_TRASH
-            ) {
-              this.inboxes.label(
-                inboxEndpoint,
-                tombstonedMessageId,
-                MESSAGE_LABEL_TRASH,
-                inboxToken
-              );
-            }
-            this.inboxes.label(
-              inboxEndpoint,
-              messageId,
-              MESSAGE_LABEL_TRASH,
-              inboxToken
-            );
-          });
-          yield {
-            messageId,
-            tombstone: true,
-            object,
-            storageBucketKey,
-            allowedTickets,
-            tags: receivedTags,
-            announcements
-          };
-        } else {
-          console.error("Recieved an incorrect object");
-          console.error(validationError);
-          this.inboxes.label(
-            inboxEndpoint,
-            messageId,
-            MESSAGE_LABEL_INVALID,
-            inboxToken
-          );
-        }
       } else {
-        if (validationError === void 0) {
-          this.inboxes.label(
-            inboxEndpoint,
-            messageId,
-            MESSAGE_LABEL_VALID,
-            inboxToken
-          );
-          yield {
-            messageId,
-            object,
-            storageBucketKey,
-            tags: receivedTags,
-            allowedTickets,
-            announcements
-          };
-        } else {
-          console.error("Recieved an incorrect object");
-          console.error(validationError);
-          this.inboxes.label(
-            inboxEndpoint,
-            messageId,
-            MESSAGE_LABEL_INVALID,
-            inboxToken
-          );
-        }
+        console.error("Recieved an incorrect object");
+        console.error(validationError);
+        this.inboxes.label(
+          inboxEndpoint,
+          messageId,
+          MESSAGE_LABEL_INVALID,
+          inboxToken
+        );
       }
     }
   }