ignotum 0.0.2 → 0.0.4

package/src/client/sync.ts

@@ -3,14 +3,19 @@ import {
   Deferred,
   Duration,
   Effect,
+  Fiber,
   HashMap,
   Layer,
   ManagedRuntime,
-  Predicate,
   Schedule,
   Schema,
 } from "effect";
 import * as Socket from "effect/unstable/socket/Socket";
+import * as BrowserCrypto from "@effect/platform-browser/BrowserCrypto";
+
+import { encodeCanonicalJson } from "@ignotum/contracts/json";
+import { type AppStateRevision } from "@ignotum/contracts/runtime/hosted";
+import { IdGenerator } from "@ignotum/shared/id";
 
 import type {
   ErrorValue,
@@ -20,12 +25,15 @@ import type {
 import { failureFromWire, pending, Result } from "@ignotum/contracts/runtime/result";
 import {
   ClientMessageJson,
-  RequestId,
+  DeploymentChangedCloseCode,
+  InvocationId,
   ServerMessageJson,
   SubscriptionId,
   decodeTransportValue,
   type ClientMessage,
   type FunctionAddress,
+  type ServerMessage,
+  type SyncHandshake,
   type WireResult,
 } from "@ignotum/contracts/runtime/sync";
 import {
@@ -33,7 +41,6 @@ import {
   ConnectionUnavailable,
   InvalidClientMessage,
   InvalidServerMessage,
-  MutationOutcomeUnknown,
   ServerProtocolError,
   clientErrorReporterLayer,
   reportClientError,
@@ -49,6 +56,7 @@ interface QueryEntry {
   readonly listeners: Set<Listener>;
   readonly subscriptionId: SubscriptionId;
   generation: number;
+  revision: AppStateRevision | undefined;
   references: number;
   result: QueryResult<unknown, ErrorValue> | ClientInfrastructureError;
 }
@@ -65,34 +73,19 @@ interface QueryCache {
   readonly entries: () => Iterable<QueryEntry>;
   readonly getById: (id: SubscriptionId) => QueryEntry | undefined;
   readonly setError: (id: SubscriptionId, error: ClientInfrastructureError) => void;
-  readonly setResult: (id: SubscriptionId, result: QueryResult<unknown, ErrorValue>) => void;
+  readonly setResult: (
+    id: SubscriptionId,
+    result: QueryResult<unknown, ErrorValue>,
+    revision: AppStateRevision,
+  ) => void;
   readonly observe: (
     functionAddress: FunctionAddress,
     args: Schema.Json,
   ) => Effect.Effect<QueryObserver>;
 }
 
-const canonicalJson = (value: Schema.Json): string => {
-  if (
-    Predicate.isNull(value) ||
-    Predicate.isString(value) ||
-    Predicate.isNumber(value) ||
-    Predicate.isBoolean(value)
-  ) {
-    return JSON.stringify(value);
-  }
-  if (globalThis.Array.isArray(value)) {
-    return `[${value.map(canonicalJson).join(",")}]`;
-  }
-
-  return `{${Object.entries(value)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`)
-    .join(",")}}`;
-};
-
 const queryKey = (functionAddress: FunctionAddress, args: Schema.Json): string =>
-  `${functionAddress}:${canonicalJson(args)}`;
+  encodeCanonicalJson([functionAddress, args]);
 
 const subscribeMessage = (entry: QueryEntry): QueryLifecycleMessage => ({
   type: "Subscribe",
@@ -102,7 +95,7 @@ const subscribeMessage = (entry: QueryEntry): QueryLifecycleMessage => ({
 });
 
 const makeQueryCache = (
-  allocateId: () => SubscriptionId,
+  allocateId: Effect.Effect<SubscriptionId>,
   sendLifecycleMessage: (message: QueryLifecycleMessage) => Effect.Effect<void>,
 ) => {
   const queries = new Map<string, QueryEntry>();
@@ -121,9 +114,10 @@ const makeQueryCache = (
         function: functionAddress,
         generation: 0,
         listeners: new Set(),
+        revision: undefined,
         references: 0,
         result: pending(),
-        subscriptionId: allocateId(),
+        subscriptionId: yield* allocateId,
       };
       queries.set(key, created);
       queryKeysById.set(created.subscriptionId, key);
@@ -185,10 +179,14 @@ const makeQueryCache = (
         listener();
       }
     },
-    setResult: (id, result) => {
+    setResult: (id, result, revision) => {
       const key = queryKeysById.get(id);
       const entry = key === undefined ? undefined : queries.get(key);
       if (entry === undefined) return;
+      if (entry.revision !== undefined && revision < entry.revision) {
+        return;
+      }
+      entry.revision = revision;
       entry.result = result;
       for (const listener of entry.listeners) {
         listener();
@@ -207,7 +205,33 @@ const resultFromWire = Effect.fn("SyncClient.resultFromWire")((wire: WireResult)
   ),
 );
 
-export const syncClientInternals = { makeQueryCache, queryIdentity: queryKey, resultFromWire };
+export const shouldReloadForCloseCode = (code: number): boolean =>
+  code === DeploymentChangedCloseCode;
+
+const handshakesMatch = (first: SyncHandshake, next: SyncHandshake): boolean =>
+  first.appId === next.appId &&
+  first.deploymentId === next.deploymentId &&
+  first.generation === next.generation;
+
+type HandshakeDecision = "Accept" | "Ignore" | "Reload";
+
+const handshakeDecision = (
+  remembered: SyncHandshake | undefined,
+  acceptedOnConnection: boolean,
+  next: SyncHandshake,
+): HandshakeDecision => {
+  if (remembered !== undefined && !handshakesMatch(remembered, next)) return "Reload";
+  return acceptedOnConnection ? "Ignore" : "Accept";
+};
+
+export const syncClientInternals = {
+  makeQueryCache,
+  handshakeDecision,
+  queryIdentity: queryKey,
+  resultFromWire,
+  handshakesMatch,
+  shouldReloadForCloseCode,
+};
 
 const socketUrl = (): string => {
   const url = new URL(syncPath, globalThis.location.href);
@@ -226,12 +250,13 @@ interface SyncClientService {
   ) => Effect.Effect<QueryObserver, ClientInfrastructureError>;
 }
 
-interface PendingMutation {
+interface PendingInvocation {
   readonly deferred: Deferred.Deferred<
     IgnotumResult<unknown, ErrorValue>,
     ClientInfrastructureError
   >;
   readonly function: FunctionAddress;
+  readonly message: Extract<ClientMessage, { readonly type: "Invoke" }>;
 }
 
 export class SyncClient extends Context.Service<SyncClient, SyncClientService>()(
@@ -240,8 +265,10 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
   static readonly layer = Layer.effect(
     SyncClient,
     Effect.gen(function* () {
-      let nextOperationId = 0;
-      let mutations = HashMap.empty<RequestId, PendingMutation>();
+      const ids = yield* IdGenerator;
+      let invocations = HashMap.empty<InvocationId, PendingInvocation>();
+      let rememberedHandshake: SyncHandshake | undefined;
+      let reloadRequested = false;
       let writer: SocketWriter | undefined;
 
       const encode = (message: ClientMessage) =>
@@ -274,56 +301,49 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
             )
           : sendWith(writer, message);
 
-      const queryCache = makeQueryCache(
-        () => SubscriptionId.make(nextOperationId++),
-        (message) =>
-          writer === undefined
-            ? Effect.void
-            : send(message).pipe(
-                Effect.catchTags({
-                  ConnectionUnavailable: reportClientError,
-                  InvalidClientMessage: reportClientError,
-                }),
-              ),
+      const queryCache = makeQueryCache(ids.generate(SubscriptionId), (message) =>
+        writer === undefined
+          ? Effect.void
+          : send(message).pipe(
+              Effect.catchTags({
+                ConnectionUnavailable: reportClientError,
+                InvalidClientMessage: reportClientError,
+              }),
+            ),
       );
 
-      const rejectMutation = (requestId: RequestId, error: ClientInfrastructureError) => {
-        const pendingMutation = HashMap.getUnsafe(mutations, requestId);
-        if (pendingMutation === undefined) {
+      const rejectInvocation = (id: InvocationId, error: ClientInfrastructureError) => {
+        const pendingInvocation = HashMap.getUnsafe(invocations, id);
+        if (pendingInvocation === undefined) {
           return Effect.void;
         }
-        mutations = HashMap.remove(mutations, requestId);
+        invocations = HashMap.remove(invocations, id);
         return reportClientError(error).pipe(
-          Effect.andThen(Deferred.fail(pendingMutation.deferred, error)),
+          Effect.andThen(Deferred.fail(pendingInvocation.deferred, error)),
           Effect.asVoid,
         );
       };
 
-      const handleMessage = Effect.fn("SyncClient.handleMessage")(function* (text: string) {
-        const message = yield* Schema.decodeEffect(ServerMessageJson)(text).pipe(
-          Effect.mapError((cause) =>
-            InvalidServerMessage.make({
-              cause,
-              message: "The server returned an invalid sync message.",
-            }),
-          ),
-        );
-
+      const handleMessage = Effect.fn("SyncClient.handleMessage")(function* (
+        message: Exclude<ServerMessage, SyncHandshake | { readonly type: "DeploymentChanged" }>,
+      ) {
         switch (message.type) {
-          case "QuerySnapshot": {
+          case "Snapshot": {
             const entry = queryCache.getById(message.id);
             if (entry === undefined) return;
             yield* resultFromWire(message.result).pipe(
-              Effect.tap((result) => Effect.sync(() => queryCache.setResult(message.id, result))),
+              Effect.tap((result) =>
+                Effect.sync(() => queryCache.setResult(message.id, result, message.revision)),
+              ),
             );
             return;
           }
-          case "MutationResult": {
-            const pendingMutation = HashMap.getUnsafe(mutations, message.id);
-            if (pendingMutation === undefined) return;
-            mutations = HashMap.remove(mutations, message.id);
+          case "Result": {
+            const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+            if (pendingInvocation === undefined) return;
+            invocations = HashMap.remove(invocations, message.id);
             yield* resultFromWire(message.result).pipe(
-              Effect.flatMap((result) => Deferred.succeed(pendingMutation.deferred, result)),
+              Effect.flatMap((result) => Deferred.succeed(pendingInvocation.deferred, result)),
             );
             return;
           }
@@ -339,9 +359,9 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
                     message: message.message,
                     operation: message.operation,
                   });
-            if (message.operation?.type === "Mutate") {
-              yield* rejectMutation(message.operation.id, error);
-            } else if (message.operation?.type === "Query") {
+            if (message.operation?.type === "Invocation") {
+              yield* rejectInvocation(message.operation.id, error);
+            } else if (message.operation?.type === "Subscription") {
               queryCache.setError(message.operation.id, error);
               yield* reportClientError(error);
             } else {
@@ -352,36 +372,81 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
         }
       });
 
-      const disconnect = Effect.gen(function* () {
+      const requestReload = () => {
+        if (reloadRequested) return;
+        reloadRequested = true;
+        writer = undefined;
+        globalThis.location.reload();
+      };
+
+      const disconnect = Effect.sync(() => {
         writer = undefined;
-        const current = mutations;
-        mutations = HashMap.empty();
-        yield* Effect.forEach(HashMap.entries(current), ([id, pendingMutation]) => {
-          const error = MutationOutcomeUnknown.make({
-            function: pendingMutation.function,
-            id,
-            message: "The connection closed before the mutation outcome was known.",
-          });
-          return reportClientError(error).pipe(
-            Effect.andThen(Deferred.fail(pendingMutation.deferred, error)),
-          );
-        });
       });
 
       const connect = Effect.scoped(
         Effect.gen(function* () {
+          if (reloadRequested) return yield* Effect.never;
           const socket = yield* Socket.makeWebSocket(socketUrl(), {
-            closeCodeIsError: () => false,
+            closeCodeIsError: (code) => {
+              if (shouldReloadForCloseCode(code)) requestReload();
+              return false;
+            },
           });
           const write = yield* socket.writer;
-          const onOpen = Effect.gen(function* () {
+          const handshakeReceived = yield* Deferred.make<void>();
+          let handshakeAccepted = false;
+          const acceptHandshake = Effect.fn("SyncClient.acceptHandshake")(function* (
+            handshake: SyncHandshake,
+          ) {
+            const decision = handshakeDecision(rememberedHandshake, handshakeAccepted, handshake);
+            if (decision === "Reload") {
+              requestReload();
+              return;
+            }
+            if (decision === "Ignore") return;
+            rememberedHandshake = handshake;
+            handshakeAccepted = true;
             writer = write;
-            yield* Effect.forEach(queryCache.entries(), (entry) =>
-              sendWith(write, subscribeMessage(entry)),
+            yield* Deferred.succeed(handshakeReceived, undefined);
+            yield* Effect.gen(function* () {
+              yield* Effect.forEach(queryCache.entries(), (entry) =>
+                sendWith(write, subscribeMessage(entry)),
+              );
+              yield* Effect.forEach(HashMap.values(invocations), (pendingInvocation) =>
+                sendWith(write, pendingInvocation.message),
+              );
+            }).pipe(Effect.tapError(reportClientError), Effect.ignore);
+          });
+
+          const handleText = Effect.fn("SyncClient.handleText")(function* (text: string) {
+            const message = yield* Schema.decodeEffect(ServerMessageJson)(text).pipe(
+              Effect.mapError((cause) =>
+                InvalidServerMessage.make({
+                  cause,
+                  message: "The server returned an invalid sync message.",
+                }),
+              ),
             );
-          }).pipe(Effect.tapError(reportClientError), Effect.ignore);
+            if (message.type === "Handshake") return yield* acceptHandshake(message);
+            if (message.type === "DeploymentChanged") {
+              requestReload();
+              return;
+            }
+            if (!handshakeAccepted) {
+              return yield* InvalidServerMessage.make({
+                cause: new Error("The server sent a sync message before the handshake."),
+                message: "The server returned a sync message before the handshake.",
+              });
+            }
+            return yield* handleMessage(message);
+          });
 
-          yield* socket.runString(handleMessage, { onOpen });
+          const run = yield* socket.runString(handleText).pipe(Effect.forkChild);
+          yield* Effect.raceFirst(
+            Deferred.await(handshakeReceived).pipe(Effect.timeout("10 seconds")),
+            Fiber.join(run),
+          );
+          yield* Fiber.join(run);
         }),
       ).pipe(
         Effect.mapError((cause) =>
@@ -422,58 +487,45 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
 
       const mutate: SyncClientService["mutate"] = Effect.fn("SyncClient.mutate")(
         function* (functionAddress, args) {
-          const requestId = RequestId.make(nextOperationId++);
+          const invocationId = yield* ids.generate(InvocationId);
           const deferred = yield* Deferred.make<
             IgnotumResult<unknown, ErrorValue>,
             ClientInfrastructureError
           >();
-          mutations = HashMap.set(mutations, requestId, {
-            deferred,
-            function: functionAddress,
-          });
           const message: ClientMessage = {
-            type: "Mutate",
-            id: requestId,
+            type: "Invoke",
+            id: invocationId,
+            kind: "Mutation",
             function: functionAddress,
             args,
           };
-          const sendMutation = Effect.gen(function* () {
-            const mutationWriter = writer;
-            if (mutationWriter === undefined) {
-              return yield* ConnectionUnavailable.make({
-                message: "The sync connection is not ready.",
-              });
-            }
-            return yield* sendWith(mutationWriter, message).pipe(
-              Effect.mapError((error) =>
-                Schema.is(InvalidClientMessage)(error)
-                  ? error
-                  : MutationOutcomeUnknown.make({
-                      cause: error,
-                      function: functionAddress,
-                      id: requestId,
-                      message: "The connection failed while sending the mutation.",
-                    }),
-              ),
-            );
+          invocations = HashMap.set(invocations, invocationId, {
+            deferred,
+            function: functionAddress,
+            message,
           });
-          yield* sendMutation.pipe(
-            Effect.tapError(reportClientError),
-            Effect.tapError(() =>
-              Effect.sync(() => (mutations = HashMap.remove(mutations, requestId))),
-            ),
-          );
+          if (writer !== undefined) {
+            yield* sendWith(writer, message).pipe(
+              Effect.catchTags({
+                ConnectionUnavailable: reportClientError,
+                InvalidClientMessage: (error) => rejectInvocation(invocationId, error),
+              }),
+            );
+          }
           return yield* Deferred.await(deferred);
         },
       );
 
       return SyncClient.of({ mutate, observe });
     }),
-  ).pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal));
+  ).pipe(Layer.provide(Layer.merge(Socket.layerWebSocketConstructorGlobal, BrowserCrypto.layer)));
 }
 
 export const syncRuntime = ManagedRuntime.make(
-  SyncClient.layer.pipe(Layer.provideMerge(clientErrorReporterLayer)),
+  SyncClient.layer.pipe(
+    Layer.provideMerge(clientErrorReporterLayer),
+    Layer.provideMerge(IdGenerator.layer),
+  ),
 );
 
 // SAFETY: Vite adds this optional property to browser development modules.