ignotum 0.0.12 → 0.0.13

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,6 +76,8 @@ 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 setResult: (
@@ -165,7 +170,19 @@ const makeQueryCache = (
     } satisfies QueryObserver;
   });
 
+  const clear = (entry: QueryEntry) => {
+    entry.result = pending();
+    entry.revision = undefined;
+    for (const listener of entry.listeners) listener();
+  };
   return {
+    invalidate: (ids) => {
+      for (const entry of queries.values())
+        if (ids === undefined || ids.includes(entry.subscriptionId)) clear(entry);
+    },
+    invalidatePrivate: () => {
+      for (const entry of queries.values()) if (entry.dependsOnId !== false) clear(entry);
+    },
     entries: () => queries.values(),
     getById: (id: SubscriptionId) => queriesById.get(id),
     observe,
@@ -251,6 +268,7 @@ interface SyncClientService {
 }
 
 interface PendingInvocation {
+  readonly sessionEpoch: string;
   readonly deferred: Deferred.Deferred<
     IgnotumResult<unknown, ErrorValue>,
     ClientInfrastructureError
@@ -270,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(
@@ -316,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;
         }
@@ -333,9 +362,52 @@ 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) =>
@@ -351,14 +423,16 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
             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;
             yield* resultFromWire(message.result).pipe(
               Effect.flatMap((result) => {
@@ -372,6 +446,7 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
             return;
           }
           case "Error": {
+            if (message.sessionEpoch !== session.current()?.sessionEpoch) return;
             const error =
               message.operation === undefined
                 ? ServerError.make({
@@ -410,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;
@@ -428,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;
@@ -465,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) =>
@@ -511,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),
@@ -559,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,
@@ -630,7 +760,9 @@ export class SyncClient extends Context.Service<SyncClient, SyncClientService>()
                 }),
                 { concurrency: 3, discard: true },
               );
-              const pendingInvocation = HashMap.getUnsafe(invocations, invocationId);
+              const pendingInvocation = Option.getOrUndefined(
+                HashMap.get(invocations, invocationId),
+              );
               if (pendingInvocation === undefined) return yield* Deferred.await(deferred);
               invocations = HashMap.set(invocations, invocationId, {
                 ...pendingInvocation,
@@ -663,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),
   ),

package/src/dev-runtime/functions.ts

@@ -1,3 +1,4 @@
+import { makeIdContext, type IdContext, type SessionState } from "@ignotum/contracts/id";
 import {
   FunctionUnavailable,
   InvalidArguments,
@@ -61,7 +62,9 @@ import {
 export { FunctionUnavailable, InvalidArguments, UnknownFunction, WrongFunctionKind };
 export type { FunctionArguments, FunctionKind };
 
-export type RuntimeHandlerContext = LocalMutationContext | LocalQueryContext;
+export type RuntimeHandlerContext = (LocalMutationContext | LocalQueryContext) & {
+  readonly id: IdContext;
+};
 export type RuntimeFunctionDefinition = InternalRuntimeFunctionDefinition<RuntimeHandlerContext>;
 
 const loadDevelopmentEnvironment = Effect.fn("DevelopmentEnvironment.load")(function* (
@@ -243,6 +246,7 @@ export class FunctionExecutor extends Context.Service<
       functionAddress: FunctionAddress,
       kind: FunctionKind,
       resolved: ResolvedFunction,
+      identity?: SessionState,
     ) => Effect.Effect<RuntimeInvocationResult>;
   }
 >()("ignotum/dev-runtime/functions/FunctionExecutor") {
@@ -282,96 +286,113 @@ export class FunctionExecutor extends Context.Service<
         );
 
       return FunctionExecutor.of({
-        execute: Effect.fn("FunctionExecutor.execute")(function* (functionAddress, kind, resolved) {
-          const invoke = (context: RuntimeHandlerContext) =>
-            Effect.gen(() =>
-              resolved.definition.handler(
-                Object.freeze({ ...context, env: resolved.environment ?? Object.freeze({}) }),
-                resolved.args,
-              ),
-            ).pipe(
-              Effect.matchEffect({
-                onFailure: (error) => encodeFailure(resolved.definition, error),
-                onSuccess: (value) => encodeSuccess(resolved.definition, value),
+        execute: Effect.fn("FunctionExecutor.execute")(
+          function* (functionAddress, kind, resolved, identity) {
+            let readId = false;
+            const id = makeIdContext(
+              Effect.sync(() => {
+                readId = true;
+                return identity?.user ?? null;
               }),
             );
+            const invoke = (context: LocalMutationContext | LocalQueryContext) =>
+              Effect.gen(() =>
+                resolved.definition.handler(
+                  Object.freeze({ ...context, id, env: resolved.environment ?? Object.freeze({}) }),
+                  resolved.args,
+                ),
+              ).pipe(
+                Effect.matchEffect({
+                  onFailure: (error) => encodeFailure(resolved.definition, error),
+                  onSuccess: (value) => encodeSuccess(resolved.definition, value),
+                }),
+              );
 
-          const execution =
-            kind === "Query"
-              ? database.trackedQueryTransaction(resolved.schema, invoke).pipe(
-                  Effect.map(
-                    ({ dependencies, observedRevision, value }): RuntimeInvocationResult => {
-                      const files =
-                        value.type === "Success" && value.value !== undefined
-                          ? encodedFileOccurrencesOf(value.value)
-                          : [];
-                      const result = {
-                        type: "Query",
-                        result: value,
-                        dependencies,
-                        observedRevision,
-                      } as const;
-                      return files.length === 0 ? result : { ...result, files };
-                    },
-                  ),
-                )
-              : mutationSemaphore.withPermits(1)(
-                  database
-                    .trackedMutationTransaction(resolved.schema, (context) =>
-                      invoke(context).pipe(
-                        Effect.flatMap((result) =>
-                          result.type === "Failure"
-                            ? Effect.fail(MutationApplicationFailure.make({ error: result.error }))
-                            : Effect.succeed(result),
-                        ),
-                      ),
-                    )
-                    .pipe(
-                      Effect.map(
-                        ({ committedRevision, invalidations, value }): RuntimeInvocationResult => ({
-                          type: "Mutation",
+            const execution =
+              kind === "Query"
+                ? database.trackedQueryTransaction(resolved.schema, invoke).pipe(
+                    Effect.map(
+                      ({ dependencies, observedRevision, value }): RuntimeInvocationResult => {
+                        const files =
+                          value.type === "Success" && value.value !== undefined
+                            ? encodedFileOccurrencesOf(value.value)
+                            : [];
+                        const result = {
+                          type: "Query",
                           result: value,
-                          invalidations,
-                          committedRevision,
-                        }),
-                      ),
-                      Effect.catchTags({
-                        MutationApplicationFailure: ({ error }) =>
-                          Effect.succeed<RuntimeInvocationResult>({
+                          dependencies: readId
+                            ? [...dependencies, { type: "Id" as const }]
+                            : dependencies,
+                          observedRevision,
+                        } as const;
+                        return files.length === 0 ? result : { ...result, files };
+                      },
+                    ),
+                  )
+                : mutationSemaphore.withPermits(1)(
+                    database
+                      .trackedMutationTransaction(resolved.schema, (context) =>
+                        invoke(context).pipe(
+                          Effect.flatMap((result) =>
+                            result.type === "Failure"
+                              ? Effect.fail(
+                                  MutationApplicationFailure.make({ error: result.error }),
+                                )
+                              : Effect.succeed(result),
+                          ),
+                        ),
+                      )
+                      .pipe(
+                        Effect.map(
+                          ({
+                            committedRevision,
+                            invalidations,
+                            value,
+                          }): RuntimeInvocationResult => ({
                             type: "Mutation",
-                            result: { type: "Failure", error },
+                            result: value,
+                            invalidations,
+                            committedRevision,
                           }),
-                      }),
-                    ),
-                );
-
-          return yield* execution.pipe(
-            Effect.orDie,
-            Effect.catchCauseIf(
-              (cause) => !Cause.hasInterruptsOnly(cause),
-              (cause) =>
-                Effect.gen(function* () {
-                  const requestId = yield* ids.generate(RequestId);
-                  yield* Effect.logError(`${functionAddress} failed during execution.`).pipe(
-                    Effect.annotateLogs({ cause, function: functionAddress, requestId }),
+                        ),
+                        Effect.catchTags({
+                          MutationApplicationFailure: ({ error }) =>
+                            Effect.succeed<RuntimeInvocationResult>({
+                              type: "Mutation",
+                              result: { type: "Failure", error },
+                            }),
+                        }),
+                      ),
                   );
-                  const result = {
-                    type: "Failure" as const,
-                    error: { _tag: "InternalServerError", requestId },
-                  };
-                  if (kind === "Mutation") {
-                    return { type: "Mutation" as const, result };
-                  }
-                  return {
-                    type: "Query" as const,
-                    result,
-                    dependencies: [],
-                    observedRevision: yield* database.revision,
-                  };
-                }),
-            ),
-          );
-        }),
+
+            return yield* execution.pipe(
+              Effect.orDie,
+              Effect.catchCauseIf(
+                (cause) => !Cause.hasInterruptsOnly(cause),
+                (cause) =>
+                  Effect.gen(function* () {
+                    const requestId = yield* ids.generate(RequestId);
+                    yield* Effect.logError(`${functionAddress} failed during execution.`).pipe(
+                      Effect.annotateLogs({ cause, function: functionAddress, requestId }),
+                    );
+                    const result = {
+                      type: "Failure" as const,
+                      error: { _tag: "InternalServerError", requestId },
+                    };
+                    if (kind === "Mutation") {
+                      return { type: "Mutation" as const, result };
+                    }
+                    return {
+                      type: "Query" as const,
+                      result,
+                      dependencies: readId ? [{ type: "Id" as const }] : [],
+                      observedRevision: yield* database.revision,
+                    };
+                  }),
+              ),
+            );
+          },
+        ),
       });
     }),
   );
@@ -384,10 +405,12 @@ export const functionRuntimeLayer = Layer.effect(
     const registry = yield* FunctionRegistry;
     const executor = yield* FunctionExecutor;
     return FunctionRuntime.of({
-      prepare: Effect.fn("DevFunctionRuntime.prepare")(function* (functionAddress, kind, args) {
-        const resolved = yield* registry.resolve(functionAddress, kind, args);
-        return { execute: executor.execute(functionAddress, kind, resolved) };
-      }),
+      prepare: Effect.fn("DevFunctionRuntime.prepare")(
+        function* (functionAddress, kind, args, identity) {
+          const resolved = yield* registry.resolve(functionAddress, kind, args);
+          return { execute: executor.execute(functionAddress, kind, resolved, identity) };
+        },
+      ),
     });
   }),
 );