Function handleMessage

packages/experimental/src/EventLogRemote.ts:321–402

(res: typeof ProtocolResponse.Type)

      }

      function handleMessage(res: typeof ProtocolResponse.Type) {
        switch (res._tag) {
          case "Hello": {
            return log.registerRemote({
              id: res.remoteId,
              write: (identity, entries) =>
                Effect.gen(function*() {
                  const encrypted = yield* encryption.encrypt(identity, entries)
                  const deferred = yield* Deferred.make<void>()
                  const id = pendingCounter++
                  pending.set(id, {
                    entries,
                    deferred,
                    publicKey: identity.publicKey
                  })
                  yield* Effect.orDie(write(
                    new WriteEntries({
                      publicKey: identity.publicKey,
                      id,
                      iv: encrypted.iv,
                      encryptedEntries: encrypted.encryptedEntries.map((encryptedEntry, i) => ({
                        entryId: entries[i].id,
                        encryptedEntry
                      }))
                    })
                  ))
                  yield* Deferred.await(deferred)
                }),
              changes: (identity, startSequence) =>
                Effect.gen(function*() {
                  const mailbox = yield* RcMap.get(subscriptions, identity.publicKey)
                  identities.set(mailbox, identity)
                  yield* Effect.orDie(write(
                    new RequestChanges({
                      publicKey: identity.publicKey,
                      startSequence
                    })
                  ))
                  return mailbox
                })
            }).pipe(Scope.extend(scope))
          }
          case "Ack": {
            return Effect.gen(function*() {
              const entry = pending.get(res.id)
              if (!entry) return
              pending.delete(res.id)
              const { deferred, entries, publicKey } = entry
              const remoteEntries = res.sequenceNumbers.map((sequenceNumber, i) => {
                const entry = entries[i]
                return new RemoteEntry({
                  remoteSequence: sequenceNumber,
                  entry
                })
              })
              const mailbox = yield* RcMap.get(subscriptions, publicKey)
              yield* mailbox.offerAll(remoteEntries)
              yield* Deferred.done(deferred, Exit.void)