ignotum 0.0.11 → 0.0.13

package/src/client/index.ts

@@ -16,7 +16,7 @@ export type {
   FileValue,
 } from "@ignotum/contracts/schema/file";
 export { Files } from "./files.js";
-export { useMutation, usePaginatedQuery, useQuery } from "./hooks.js";
+export { useId, useMutation, usePaginatedQuery, useQuery } from "./hooks.js";
 export type { PaginatedQueryOptions, PaginatedQueryValue, PaginationStatus } from "./hooks.js";
 export { Query } from "./query.js";
 export type { QuerySkip } from "./query.js";
@@ -89,7 +89,7 @@ export {
   useDebugValue,
   useEffect,
   useErrorBoundary,
-  useId,
+  useId as useElementId,
   useImperativeHandle,
   useLayoutEffect,
   useMemo,
@@ -98,3 +98,6 @@ export {
   useState,
 } from "preact/hooks";
 export type { Dispatch, Reducer, StateUpdater } from "preact/hooks";
+
+export type { User, UserId, ProfileField } from "@ignotum/contracts/id";
+export type { IdResult, IdOptions } from "./hooks.js";

package/src/client/page-observers.ts

@@ -0,0 +1,77 @@
+import { Effect, Schema } from "effect";
+
+import type { FunctionAddress } from "@ignotum/contracts/runtime/sync";
+import { SyncClient, syncClientInternals } from "./sync.js";
+import type { ClientInfrastructureError } from "./errors.js";
+
+type QueryObserver = Effect.Success<ReturnType<SyncClient["Service"]["observe"]>>;
+
+interface PageEntry {
+  readonly acquire: Effect.Effect<QueryObserver | undefined, ClientInfrastructureError, SyncClient>;
+  release: (() => void) | undefined;
+  released: boolean;
+}
+
+// @effect-diagnostics-next-line missingPipeableSignature:off This hook-owned lifecycle takes two callbacks, not a data argument.
+export const makePageObservers = (
+  onChange: () => void,
+  releaseObserver: (release: Effect.Effect<void>) => void,
+) => {
+  const pages = new Map<string, PageEntry>();
+  let disposed = false;
+
+  const releaseEntry = (entry: PageEntry) => {
+    entry.released = true;
+    entry.release?.();
+  };
+
+  const observe = Effect.fn("PageObservers.observe")(function* (
+    functionAddress: FunctionAddress,
+    args: Schema.Json,
+  ) {
+    if (disposed) return;
+    const key = syncClientInternals.queryIdentity(functionAddress, args);
+    const existing = pages.get(key);
+    if (existing !== undefined) return yield* existing.acquire;
+
+    const entry: PageEntry = {
+      acquire: yield* Effect.cached(
+        Effect.gen(function* () {
+          const client = yield* SyncClient;
+          const observer = yield* client.observe(functionAddress, args);
+          if (entry.released) {
+            releaseObserver(observer.release);
+            return;
+          }
+          const unsubscribe = observer.subscribe(onChange);
+          entry.release = () => {
+            unsubscribe();
+            releaseObserver(observer.release);
+          };
+          return observer;
+        }),
+      ),
+      release: undefined,
+      released: false,
+    };
+    pages.set(key, entry);
+    return yield* entry.acquire;
+  });
+
+  return {
+    observe,
+    retain: (keys: ReadonlySet<string>) => {
+      for (const [key, entry] of pages) {
+        if (keys.has(key)) continue;
+        pages.delete(key);
+        releaseEntry(entry);
+      }
+    },
+    release: () => {
+      if (disposed) return;
+      disposed = true;
+      for (const entry of pages.values()) releaseEntry(entry);
+      pages.clear();
+    },
+  };
+};

package/src/client/sync.ts

@@ -1,3 +1,4 @@
+import { BrowserSession } from "./id.js";
 import {
   Context,
   Deferred,
@@ -7,6 +8,7 @@ import {
   HashMap,
   Layer,
   ManagedRuntime,
+  Option,
   Schedule,
   Schema,
 } from "effect";
@@ -59,6 +61,7 @@ interface QueryEntry {
   readonly listeners: Set<Listener>;
   readonly subscriptionId: SubscriptionId;
   generation: number;
+  dependsOnId?: boolean;
   revision: AppStateRevision | undefined;
   references: number;
   result: QueryResult<unknown, ErrorValue> | ClientInfrastructureError;
@@ -73,13 +76,14 @@ interface QueryObserver {
 type QueryLifecycleMessage = Extract<ClientMessage, { readonly type: "Subscribe" | "Unsubscribe" }>;
 
 interface QueryCache {
+  readonly invalidate: (ids?: ReadonlyArray<SubscriptionId>) => void;
+  readonly invalidatePrivate: () => void;
   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>,
-    revision: AppStateRevision,
+    result: QueryResult<unknown, ErrorValue> | ClientInfrastructureError,
+    revision?: AppStateRevision,
   ) => void;
   readonly observe: (
     functionAddress: FunctionAddress,
@@ -102,7 +106,7 @@ const makeQueryCache = (
   sendLifecycleMessage: (message: QueryLifecycleMessage) => Effect.Effect<void>,
 ) => {
   const queries = new Map<string, QueryEntry>();
-  const queryKeysById = new Map<SubscriptionId, string>();
+  const queriesById = new Map<SubscriptionId, QueryEntry>();
 
   const observe = Effect.fn("SyncClient.QueryCache.observe")(function* (
     functionAddress: FunctionAddress,
@@ -123,7 +127,7 @@ const makeQueryCache = (
         subscriptionId: yield* allocateId,
       };
       queries.set(key, created);
-      queryKeysById.set(created.subscriptionId, key);
+      queriesById.set(created.subscriptionId, created);
       yield* sendLifecycleMessage(subscribeMessage(created));
       entry = created;
     }
@@ -157,7 +161,7 @@ const makeQueryCache = (
         }
 
         queries.delete(key);
-        queryKeysById.delete(observed.subscriptionId);
+        queriesById.delete(observed.subscriptionId);
         yield* sendLifecycleMessage({
           type: "Unsubscribe",
           id: observed.subscriptionId,
@@ -166,30 +170,29 @@ const makeQueryCache = (
     } satisfies QueryObserver;
   });
 
+  const clear = (entry: QueryEntry) => {
+    entry.result = pending();
+    entry.revision = undefined;
+    for (const listener of entry.listeners) listener();
+  };
   return {
-    entries: () => queries.values(),
-    getById: (id: SubscriptionId) => {
-      const key = queryKeysById.get(id);
-      return key === undefined ? undefined : queries.get(key);
+    invalidate: (ids) => {
+      for (const entry of queries.values())
+        if (ids === undefined || ids.includes(entry.subscriptionId)) clear(entry);
     },
-    observe,
-    setError: (id, error) => {
-      const key = queryKeysById.get(id);
-      const entry = key === undefined ? undefined : queries.get(key);
-      if (entry === undefined) return;
-      entry.result = error;
-      for (const listener of entry.listeners) {
-        listener();
-      }
+    invalidatePrivate: () => {
+      for (const entry of queries.values()) if (entry.dependsOnId !== false) clear(entry);
     },
-    setResult: (id, result, revision) => {
-      const key = queryKeysById.get(id);
-      const entry = key === undefined ? undefined : queries.get(key);
+    entries: () => queries.values(),
+    getById: (id: SubscriptionId) => queriesById.get(id),
+    observe,
+    setResult: (id, result, revision?: AppStateRevision) => {
+      const entry = queriesById.get(id);
       if (entry === undefined) return;
-      if (entry.revision !== undefined && revision < entry.revision) {
-        return;
+      if (revision !== undefined) {
+        if (entry.revision !== undefined && revision < entry.revision) return;
+        entry.revision = revision;
       }
-      entry.revision = revision;
       entry.result = result;
       for (const listener of entry.listeners) {
         listener();
@@ -202,15 +205,21 @@ type SnapshotFiles = NonNullable<Extract<ServerMessage, { readonly type: "Snapsh
 
 const resultFromWire = Effect.fn("SyncClient.resultFromWire")(
   (wire: WireResult, files: SnapshotFiles = []) =>
-    Effect.succeed(
-      wire.type === "Success"
-        ? Result.succeed(
-            wire.value === undefined
-              ? undefined
-              : applyFileGrants(decodeTransportValue(wire.value, wire.dates ?? []), files),
-          )
-        : failureFromWire(wire.error, wire.dates),
-    ),
+    Effect.try({
+      try: () =>
+        wire.type === "Success"
+          ? Result.succeed(
+              wire.value === undefined
+                ? undefined
+                : applyFileGrants(decodeTransportValue(wire.value, wire.dates ?? []), files),
+            )
+          : failureFromWire(wire.error, wire.dates),
+      catch: (cause) =>
+        InvalidServerMessage.make({
+          cause,
+          message: "The server returned an invalid function result.",
+        }),
+    }),
 );
 
 export const shouldReloadForCloseCode = (code: number): boolean => code === DeploymentCloseCode;
@@ -259,6 +268,7 @@ interface SyncClientService {
 }
 
 interface PendingInvocation {
+  readonly sessionEpoch: string;
   readonly deferred: Deferred.Deferred<
     IgnotumResult<unknown, ErrorValue>,
     ClientInfrastructureError
@@ -278,10 +288,12 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
     SyncClient,
     Effect.gen(function* () {
       const ids = yield* IdGenerator;
+      const session = yield* BrowserSession;
       let invocations = HashMap.empty<InvocationId, PendingInvocation>();
       let rememberedHandshake: SyncHandshake | undefined;
       let reloadRequested = false;
       let writer: SocketWriter | undefined;
+      let sessionSuspended: Deferred.Deferred<void> | undefined;
 
       const encode = (message: ClientMessage) =>
         Schema.encodeEffect(ClientMessageJson)(message).pipe(
@@ -324,8 +336,17 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
             ),
       );
 
+      const unsubscribeSession = session.subscribe(() => {
+        if (session.current() === undefined) {
+          queryCache.invalidatePrivate();
+          writer = undefined;
+          if (sessionSuspended !== undefined) Deferred.doneUnsafe(sessionSuspended, Effect.void);
+        }
+      });
+      yield* Effect.addFinalizer(() => Effect.sync(unsubscribeSession));
+
       const rejectInvocation = (id: InvocationId, error: ClientInfrastructureError) => {
-        const pendingInvocation = HashMap.getUnsafe(invocations, id);
+        const pendingInvocation = Option.getOrUndefined(HashMap.get(invocations, id));
         if (pendingInvocation === undefined) {
           return Effect.void;
         }
@@ -341,33 +362,91 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
         message: Exclude<ServerMessage, SyncHandshake | { readonly type: "Deployment" }>,
       ) {
         switch (message.type) {
+          case "Session": {
+            if (message.event === "Updated") {
+              const previous = session.current();
+              if (previous !== undefined && previous.sessionEpoch !== message.session.sessionEpoch)
+                return;
+              if (previous?.viewRevision !== message.session.viewRevision)
+                queryCache.invalidatePrivate();
+              session.accept(message.session, message.serverTime);
+            } else {
+              if (rememberedHandshake?.session?.sessionEpoch !== message.sessionEpoch) return;
+              session.suspend(
+                message.event === "Unavailable"
+                  ? "Your ID session is temporarily unavailable."
+                  : undefined,
+              );
+              if (message.event !== "Unavailable") {
+                yield* Effect.forEach(HashMap.keys(invocations), (id) =>
+                  rejectInvocation(
+                    id,
+                    ServerError.make({
+                      code: "SessionChanged",
+                      message: "The session changed. This operation may already have completed.",
+                    }),
+                  ),
+                );
+              }
+            }
+            return;
+          }
+          case "Invalidate": {
+            if (message.sessionEpoch === session.current()?.sessionEpoch)
+              queryCache.invalidate(message.ids);
+            return;
+          }
           case "Snapshot": {
+            const current = session.current();
+            if (current === undefined || message.identity?.sessionEpoch !== current.sessionEpoch)
+              return;
+            if (
+              message.identity.dependsOnId &&
+              message.identity.viewRevision !== current.viewRevision
+            )
+              return;
             const entry = queryCache.getById(message.id);
             if (entry === undefined) return;
+            entry.dependsOnId = message.identity.dependsOnId;
+            if (entry.revision !== undefined && message.revision < entry.revision) return;
             yield* resultFromWire(message.result, message.files ?? []).pipe(
               Effect.tap((result) =>
                 Effect.sync(() => queryCache.setResult(message.id, result, message.revision)),
               ),
+              Effect.catchTags({
+                InvalidServerMessage: (error) => {
+                  queryCache.setResult(message.id, error, message.revision);
+                  return reportClientError(error);
+                },
+              }),
             );
             return;
           }
           case "Preparation": {
-            const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+            if (message.sessionEpoch !== session.current()?.sessionEpoch) return;
+            const pendingInvocation = Option.getOrUndefined(HashMap.get(invocations, message.id));
             if (pendingInvocation !== undefined) {
               yield* Deferred.succeed(pendingInvocation.prepared, message.uploads);
             }
             return;
           }
           case "Result": {
-            const pendingInvocation = HashMap.getUnsafe(invocations, message.id);
+            if (message.sessionEpoch !== session.current()?.sessionEpoch) return;
+            const pendingInvocation = Option.getOrUndefined(HashMap.get(invocations, message.id));
             if (pendingInvocation === undefined) return;
-            invocations = HashMap.remove(invocations, message.id);
             yield* resultFromWire(message.result).pipe(
-              Effect.flatMap((result) => Deferred.succeed(pendingInvocation.deferred, result)),
+              Effect.flatMap((result) => {
+                invocations = HashMap.remove(invocations, message.id);
+                return Deferred.succeed(pendingInvocation.deferred, result);
+              }),
+              Effect.catchTags({
+                InvalidServerMessage: (error) => rejectInvocation(message.id, error),
+              }),
             );
             return;
           }
           case "Error": {
+            if (message.sessionEpoch !== session.current()?.sessionEpoch) return;
             const error =
               message.operation === undefined
                 ? ServerError.make({
@@ -382,7 +461,7 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
             if (message.operation?.type === "Invocation") {
               yield* rejectInvocation(message.operation.id, error);
             } else if (message.operation?.type === "Subscription") {
-              queryCache.setError(message.operation.id, error);
+              queryCache.setResult(message.operation.id, error);
               yield* reportClientError(error);
             } else {
               yield* reportClientError(error);
@@ -406,12 +485,18 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
       const connect = Effect.scoped(
         Effect.gen(function* () {
           if (reloadRequested) return yield* Effect.never;
-          const socket = yield* Socket.makeWebSocket(socketUrl(), {
-            closeCodeIsError: (code) => {
-              if (shouldReloadForCloseCode(code)) requestReload();
-              return false;
+          yield* session.bootstrap.pipe(
+            Effect.mapError((error) => ConnectionUnavailable.make({ message: error.message })),
+          );
+          const socket = yield* Socket.makeWebSocket(
+            `${socketUrl()}${session.socketParameters()}`,
+            {
+              closeCodeIsError: (code) => {
+                if (shouldReloadForCloseCode(code)) requestReload();
+                return false;
+              },
             },
-          });
+          );
           const write = yield* socket.writer;
           const handshakeReceived = yield* Deferred.make<void>();
           let handshakeAccepted = false;
@@ -424,6 +509,41 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
               return;
             }
             if (decision === "Ignore") return;
+            if (handshake.session === undefined || handshake.serverTime === undefined) {
+              requestReload();
+              return;
+            }
+            if (
+              rememberedHandshake?.session !== undefined &&
+              rememberedHandshake.session.sessionEpoch !== handshake.session.sessionEpoch
+            ) {
+              queryCache.invalidatePrivate();
+              yield* Effect.forEach(HashMap.keys(invocations), (id) =>
+                rejectInvocation(
+                  id,
+                  ServerError.make({
+                    code: "SessionChanged",
+                    message: "The session changed. This operation may already have completed.",
+                  }),
+                ),
+              );
+            } else if (
+              rememberedHandshake?.session?.viewRevision !== handshake.session.viewRevision
+            ) {
+              queryCache.invalidatePrivate();
+            }
+            yield* Effect.forEach(HashMap.entries(invocations), ([id, pending]) =>
+              pending.sessionEpoch === handshake.session!.sessionEpoch
+                ? Effect.void
+                : rejectInvocation(
+                    id,
+                    ServerError.make({
+                      code: "SessionChanged",
+                      message: "The session changed. This operation may already have completed.",
+                    }),
+                  ),
+            );
+            session.accept(handshake.session, handshake.serverTime);
             rememberedHandshake = handshake;
             handshakeAccepted = true;
             writer = write;
@@ -461,12 +581,19 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
             return yield* handleMessage(message);
           });
 
+          const suspended = yield* Deferred.make<void>();
+          sessionSuspended = suspended;
+          yield* Effect.addFinalizer(() =>
+            Effect.sync(() => {
+              if (sessionSuspended === suspended) sessionSuspended = undefined;
+            }),
+          );
           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);
+          yield* Effect.raceFirst(Fiber.join(run), Deferred.await(suspended));
         }),
       ).pipe(
         Effect.mapError((cause) =>
@@ -507,6 +634,12 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
 
       const mutate: SyncClientService["mutate"] = Effect.fn("SyncClient.mutate")(
         function* (functionAddress, args) {
+          const admittedSession =
+            session.current() ??
+            rememberedHandshake?.session ??
+            (yield* session.bootstrap.pipe(
+              Effect.mapError((error) => ConnectionUnavailable.make({ message: error.message })),
+            ));
           const invocationId = yield* ids.generate(InvocationId);
           const preparedArguments = yield* prepareMutationArguments(args).pipe(
             Effect.provideService(IdGenerator, ids),
@@ -555,6 +688,7 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
                   files: preparedArguments.fileIds,
                 };
           invocations = HashMap.set(invocations, invocationId, {
+            sessionEpoch: admittedSession.sessionEpoch,
             deferred,
             function: functionAddress,
             message,
@@ -573,6 +707,7 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
               const uploads = yield* Deferred.await(prepared);
               const expected = new Set(message.files);
               const received = new Set<string>();
+              const transfers: Array<{ readonly file: File; readonly url: string }> = [];
               for (const upload of uploads) {
                 if (!expected.has(upload.id) || received.has(upload.id)) {
                   return yield* InvalidServerMessage.make({
@@ -589,28 +724,7 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
                   });
                 }
                 if (upload.url === undefined) continue;
-                const uploadUrl = upload.url;
-                const response = yield* Effect.tryPromise({
-                  try: () =>
-                    fetch(uploadUrl, {
-                      method: "PUT",
-                      body: file,
-                      headers: { "content-type": file.type },
-                    }),
-                  catch: (cause) =>
-                    ConnectionUnavailable.make({
-                      cause,
-                      message: `File '${file.name}' could not be uploaded.`,
-                    }),
-                });
-                if (!response.ok) {
-                  const detail = yield* Effect.promise(() => response.text());
-                  return yield* InvalidMutationArguments.make({
-                    cause: new Error(detail),
-                    function: functionAddress,
-                    message: `File '${file.name}' was rejected by application storage.`,
-                  });
-                }
+                transfers.push({ file, url: upload.url });
               }
               if (received.size !== expected.size) {
                 return yield* InvalidServerMessage.make({
@@ -618,7 +732,37 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
                   message: "The server returned incomplete application file preparation data.",
                 });
               }
-              const pendingInvocation = HashMap.getUnsafe(invocations, invocationId);
+              yield* Effect.forEach(
+                transfers,
+                Effect.fn("SyncClient.uploadFile")(function* ({ file, url }) {
+                  const response = yield* Effect.tryPromise({
+                    try: (signal) =>
+                      fetch(url, {
+                        method: "PUT",
+                        body: file,
+                        headers: { "content-type": file.type },
+                        signal,
+                      }),
+                    catch: (cause) =>
+                      ConnectionUnavailable.make({
+                        cause,
+                        message: `File '${file.name}' could not be uploaded.`,
+                      }),
+                  });
+                  if (!response.ok) {
+                    const detail = yield* Effect.promise(() => response.text());
+                    return yield* InvalidMutationArguments.make({
+                      cause: new Error(detail),
+                      function: functionAddress,
+                      message: `File '${file.name}' was rejected by application storage.`,
+                    });
+                  }
+                }),
+                { concurrency: 3, discard: true },
+              );
+              const pendingInvocation = Option.getOrUndefined(
+                HashMap.get(invocations, invocationId),
+              );
               if (pendingInvocation === undefined) return yield* Deferred.await(deferred);
               invocations = HashMap.set(invocations, invocationId, {
                 ...pendingInvocation,
@@ -651,6 +795,7 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
 
 export const syncRuntime = ManagedRuntime.make(
   SyncClient.layer.pipe(
+    Layer.provideMerge(BrowserSession.layer),
     Layer.provideMerge(clientErrorReporterLayer),
     Layer.provideMerge(IdGenerator.layer),
   ),