@undefineds.co/xpod 0.4.8 → 0.4.10

package/node_modules/@undefineds.co/solid-sdk/dist/index.cjs

@@ -117,11 +117,24 @@ function createSolidSessionRuntime(options = {}) {
   let isInitializing = false;
   let initializationErrorSnapshot;
   let disposed = false;
+  let authenticationGeneration = 0;
+  let authenticationUnavailable = false;
+  let authenticationOperations = 0;
+  let identityOperationGeneration = 0;
+  let pendingIdentity;
+  const invalidateAuthentication = () => {
+    authenticationGeneration += 1;
+    authenticationUnavailable = true;
+  };
   const publish = (nextSnapshot) => {
-    snapshot = nextSnapshot;
-    if (disposed) {
+    if (disposed)
       return snapshot;
+    if (nextSnapshot.status !== "authenticated" || snapshot.status !== "authenticated" || snapshot.webId !== nextSnapshot.webId) {
+      invalidateAuthentication();
     }
+    if (nextSnapshot.status === "authenticated")
+      authenticationUnavailable = false;
+    snapshot = nextSnapshot;
     if (areSnapshotsEqual(lastNotifiedSnapshot, snapshot)) {
       return snapshot;
     }
@@ -131,10 +144,28 @@ function createSolidSessionRuntime(options = {}) {
     }
     return snapshot;
   };
-  const publishSessionInfo = () => publish(snapshotFromSessionInfo(session.info));
-  const publishAnonymous = () => publish({ status: "anonymous" });
-  const publishSessionExpired = () => publish(snapshotFromSessionExpired(session.info));
+  const publishSessionInfo = () => {
+    if (pendingIdentity) {
+      if (pendingIdentity.generation !== identityOperationGeneration)
+        return snapshot;
+      if (pendingIdentity.eventWebId && pendingIdentity.eventWebId !== session.info.webId)
+        return snapshot;
+      pendingIdentity.eventWebId = session.info.webId;
+    }
+    invalidateAuthentication();
+    lastNotifiedSnapshot = undefined;
+    return publish(snapshotFromSessionInfo(session.info));
+  };
+  const publishAnonymous = () => {
+    identityOperationGeneration += 1;
+    return publish({ status: "anonymous" });
+  };
+  const publishSessionExpired = () => {
+    identityOperationGeneration += 1;
+    return publish(snapshotFromSessionExpired(session.info));
+  };
   const publishSessionError = (code, description) => {
+    identityOperationGeneration += 1;
     const errorSnapshot = snapshotFromSessionError(description ?? code ?? "Solid session error", session.info);
     if (isInitializing) {
       initializationErrorSnapshot = errorSnapshot;
@@ -149,6 +180,29 @@ function createSolidSessionRuntime(options = {}) {
   errorEvents.on(import_solid_client_authn_browser.EVENTS.ERROR, publishSessionError);
   return {
     fetch: session.fetch,
+    createAuthenticatedFetch(webId) {
+      const generation = authenticationGeneration;
+      const assertCurrent = () => {
+        if (disposed || authenticationOperations > 0 || authenticationUnavailable || generation !== authenticationGeneration || snapshot.status !== "authenticated" || snapshot.webId !== webId || !session.info.isLoggedIn || session.info.webId !== webId) {
+          const error = new Error("Authenticated session is no longer current");
+          error.name = "AbortError";
+          throw error;
+        }
+      };
+      return async (input, init) => {
+        assertCurrent();
+        const response = await (init === undefined ? session.fetch(input) : session.fetch(input, init));
+        try {
+          assertCurrent();
+        } catch (error) {
+          response.body?.cancel().catch(() => {
+            return;
+          });
+          throw error;
+        }
+        return response;
+      };
+    },
     getSnapshot() {
       return snapshot;
     },
@@ -159,20 +213,29 @@ function createSolidSessionRuntime(options = {}) {
       if (initialized) {
         return Promise.resolve(snapshot);
       }
+      if (disposed)
+        return Promise.resolve(snapshot);
+      const operation = { generation: ++identityOperationGeneration, eventWebId: undefined };
+      pendingIdentity = operation;
+      const isCurrentOperation = (info) => !disposed && operation.generation === identityOperationGeneration && (!info?.isLoggedIn || !operation.eventWebId || operation.eventWebId === info.webId);
       isInitializing = true;
       initializationErrorSnapshot = undefined;
       publish({ status: "initializing" });
       const nextInitialization = session.handleIncomingRedirect({
         restorePreviousSession: options2.restorePreviousSession ?? true
       }).then((info) => {
+        if (!isCurrentOperation(info ?? session.info))
+          return snapshot;
         const nextSnapshot = snapshotFromSessionInfo(info ?? session.info);
         if (nextSnapshot.status === "anonymous" && initializationErrorSnapshot?.status === "error") {
           return initializationErrorSnapshot;
         }
         initialized = true;
         return publish(nextSnapshot);
-      }).catch((error) => publish(snapshotFromSessionError(error, session.info))).finally(() => {
+      }).catch((error) => isCurrentOperation() ? publish(snapshotFromSessionError(error, session.info)) : snapshot).finally(() => {
         if (initialization === nextInitialization) {
+          if (pendingIdentity === operation)
+            pendingIdentity = undefined;
           initialization = undefined;
           isInitializing = false;
           initializationErrorSnapshot = undefined;
@@ -185,18 +248,27 @@ function createSolidSessionRuntime(options = {}) {
       if (initialization) {
         return initialization;
       }
+      if (disposed)
+        return Promise.resolve(snapshot);
+      const operation = { generation: ++identityOperationGeneration, eventWebId: undefined };
+      pendingIdentity = operation;
+      const isCurrentOperation = (info) => !disposed && operation.generation === identityOperationGeneration && (!info?.isLoggedIn || !operation.eventWebId || operation.eventWebId === info.webId);
       isInitializing = true;
       initializationErrorSnapshot = undefined;
       publish({ status: "initializing" });
       const nextInitialization = session.handleIncomingRedirect(url).then((info) => {
+        if (!isCurrentOperation(info ?? session.info))
+          return snapshot;
         const nextSnapshot = snapshotFromSessionInfo(info ?? session.info);
         if (nextSnapshot.status === "anonymous" && initializationErrorSnapshot?.status === "error") {
           return initializationErrorSnapshot;
         }
         initialized = true;
         return publish(nextSnapshot);
-      }).catch((error) => publish(snapshotFromSessionError(error, session.info))).finally(() => {
+      }).catch((error) => isCurrentOperation() ? publish(snapshotFromSessionError(error, session.info)) : snapshot).finally(() => {
         if (initialization === nextInitialization) {
+          if (pendingIdentity === operation)
+            pendingIdentity = undefined;
           initialization = undefined;
           isInitializing = false;
           initializationErrorSnapshot = undefined;
@@ -205,12 +277,39 @@ function createSolidSessionRuntime(options = {}) {
       initialization = nextInitialization;
       return nextInitialization;
     },
-    login(options2) {
-      return session.login(options2);
+    async login(options2) {
+      identityOperationGeneration += 1;
+      invalidateAuthentication();
+      authenticationOperations += 1;
+      try {
+        if (initialization) {
+          const error = new Error("Previous login is still completing. Reload before reconnecting.");
+          error.name = "SolidSessionPendingError";
+          throw error;
+        }
+        if (disposed)
+          throw new Error("Solid session runtime is disposed");
+        await session.login(options2);
+      } catch (error) {
+        publish(snapshotFromSessionError(error, session.info));
+        throw error;
+      } finally {
+        authenticationOperations -= 1;
+      }
     },
     async logout(options2) {
-      await session.logout(options2);
-      publish({ status: "anonymous" });
+      identityOperationGeneration += 1;
+      invalidateAuthentication();
+      authenticationOperations += 1;
+      try {
+        await session.logout(options2);
+        publish({ status: "anonymous" });
+      } catch (error) {
+        publish(snapshotFromSessionError(error, session.info));
+        throw error;
+      } finally {
+        authenticationOperations -= 1;
+      }
     },
     subscribe(listener) {
       listeners.add(listener);
@@ -219,6 +318,8 @@ function createSolidSessionRuntime(options = {}) {
       };
     },
     dispose() {
+      identityOperationGeneration += 1;
+      invalidateAuthentication();
       disposed = true;
       listeners.clear();
       session.events.off(import_solid_client_authn_browser.EVENTS.LOGIN, publishSessionInfo);

package/node_modules/@undefineds.co/solid-sdk/dist/session.d.ts

@@ -31,6 +31,8 @@ export type SolidSessionAdapter = {
 };
 export type SolidSessionRuntime = {
     readonly fetch: typeof fetch;
+    /** A revocable capability for this exact WebID and authenticated session. */
+    createAuthenticatedFetch(webId: string): typeof fetch;
     getSnapshot(): SolidSessionSnapshot;
     initialize(options?: {
         restorePreviousSession?: boolean;

package/node_modules/@undefineds.co/solid-sdk/dist/session.js

@@ -46,11 +46,27 @@ export function createSolidSessionRuntime(options = {}) {
     let isInitializing = false;
     let initializationErrorSnapshot;
     let disposed = false;
+    let authenticationGeneration = 0;
+    let authenticationUnavailable = false;
+    let authenticationOperations = 0;
+    // Redirect completion has a lifecycle separate from signer renewal. Its own
+    // LOGIN event may advance authenticationGeneration without cancelling it.
+    let identityOperationGeneration = 0;
+    let pendingIdentity;
+    const invalidateAuthentication = () => {
+        authenticationGeneration += 1;
+        authenticationUnavailable = true;
+    };
     const publish = (nextSnapshot) => {
-        snapshot = nextSnapshot;
-        if (disposed) {
+        if (disposed)
             return snapshot;
+        if (nextSnapshot.status !== 'authenticated'
+            || snapshot.status !== 'authenticated' || snapshot.webId !== nextSnapshot.webId) {
+            invalidateAuthentication();
         }
+        if (nextSnapshot.status === 'authenticated')
+            authenticationUnavailable = false;
+        snapshot = nextSnapshot;
         if (areSnapshotsEqual(lastNotifiedSnapshot, snapshot)) {
             return snapshot;
         }
@@ -60,10 +76,32 @@ export function createSolidSessionRuntime(options = {}) {
         }
         return snapshot;
     };
-    const publishSessionInfo = () => publish(snapshotFromSessionInfo(session.info));
-    const publishAnonymous = () => publish({ status: 'anonymous' });
-    const publishSessionExpired = () => publish(snapshotFromSessionExpired(session.info));
+    const publishSessionInfo = () => {
+        // Inrupt may emit LOGIN while a cancelled redirect is still settling.
+        // These events cannot restore authority after logout/disposal.
+        if (pendingIdentity) {
+            if (pendingIdentity.generation !== identityOperationGeneration)
+                return snapshot;
+            if (pendingIdentity.eventWebId && pendingIdentity.eventWebId !== session.info.webId)
+                return snapshot;
+            pendingIdentity.eventWebId = session.info.webId;
+        }
+        // LOGIN/RESTORED establishes a new session even when the WebID is unchanged.
+        // Token renewal changes Inrupt's signer without these login events.
+        invalidateAuthentication();
+        lastNotifiedSnapshot = undefined;
+        return publish(snapshotFromSessionInfo(session.info));
+    };
+    const publishAnonymous = () => {
+        identityOperationGeneration += 1;
+        return publish({ status: 'anonymous' });
+    };
+    const publishSessionExpired = () => {
+        identityOperationGeneration += 1;
+        return publish(snapshotFromSessionExpired(session.info));
+    };
     const publishSessionError = (code, description) => {
+        identityOperationGeneration += 1;
         const errorSnapshot = snapshotFromSessionError(description ?? code ?? 'Solid session error', session.info);
         if (isInitializing) {
             initializationErrorSnapshot = errorSnapshot;
@@ -78,6 +116,32 @@ export function createSolidSessionRuntime(options = {}) {
     errorEvents.on(EVENTS.ERROR, publishSessionError);
     return {
         fetch: session.fetch,
+        createAuthenticatedFetch(webId) {
+            const generation = authenticationGeneration;
+            const assertCurrent = () => {
+                if (disposed || authenticationOperations > 0 || authenticationUnavailable || generation !== authenticationGeneration
+                    || snapshot.status !== 'authenticated' || snapshot.webId !== webId
+                    || !session.info.isLoggedIn || session.info.webId !== webId) {
+                    const error = new Error('Authenticated session is no longer current');
+                    error.name = 'AbortError';
+                    throw error;
+                }
+            };
+            return async (input, init) => {
+                assertCurrent();
+                const response = await (init === undefined ? session.fetch(input) : session.fetch(input, init));
+                try {
+                    assertCurrent();
+                }
+                catch (error) {
+                    // The request may already have reached the server. Discard its stale
+                    // response rather than returning it to the previous identity's work.
+                    void response.body?.cancel().catch(() => undefined);
+                    throw error;
+                }
+                return response;
+            };
+        },
         getSnapshot() {
             return snapshot;
         },
@@ -92,12 +156,21 @@ export function createSolidSessionRuntime(options = {}) {
             if (initialized) {
                 return Promise.resolve(snapshot);
             }
+            if (disposed)
+                return Promise.resolve(snapshot);
+            const operation = { generation: ++identityOperationGeneration, eventWebId: undefined };
+            pendingIdentity = operation;
+            const isCurrentOperation = (info) => !disposed
+                && operation.generation === identityOperationGeneration
+                && (!info?.isLoggedIn || !operation.eventWebId || operation.eventWebId === info.webId);
             isInitializing = true;
             initializationErrorSnapshot = undefined;
             publish({ status: 'initializing' });
             const nextInitialization = session.handleIncomingRedirect({
                 restorePreviousSession: options.restorePreviousSession ?? true,
             }).then((info) => {
+                if (!isCurrentOperation(info ?? session.info))
+                    return snapshot;
                 const nextSnapshot = snapshotFromSessionInfo(info ?? session.info);
                 if (nextSnapshot.status === 'anonymous' && initializationErrorSnapshot?.status === 'error') {
                     return initializationErrorSnapshot;
@@ -105,9 +178,12 @@ export function createSolidSessionRuntime(options = {}) {
                 initialized = true;
                 return publish(nextSnapshot);
             })
-                .catch((error) => publish(snapshotFromSessionError(error, session.info)))
+                .catch((error) => isCurrentOperation()
+                ? publish(snapshotFromSessionError(error, session.info)) : snapshot)
                 .finally(() => {
                 if (initialization === nextInitialization) {
+                    if (pendingIdentity === operation)
+                        pendingIdentity = undefined;
                     initialization = undefined;
                     isInitializing = false;
                     initializationErrorSnapshot = undefined;
@@ -120,10 +196,19 @@ export function createSolidSessionRuntime(options = {}) {
             if (initialization) {
                 return initialization;
             }
+            if (disposed)
+                return Promise.resolve(snapshot);
+            const operation = { generation: ++identityOperationGeneration, eventWebId: undefined };
+            pendingIdentity = operation;
+            const isCurrentOperation = (info) => !disposed
+                && operation.generation === identityOperationGeneration
+                && (!info?.isLoggedIn || !operation.eventWebId || operation.eventWebId === info.webId);
             isInitializing = true;
             initializationErrorSnapshot = undefined;
             publish({ status: 'initializing' });
             const nextInitialization = session.handleIncomingRedirect(url).then((info) => {
+                if (!isCurrentOperation(info ?? session.info))
+                    return snapshot;
                 const nextSnapshot = snapshotFromSessionInfo(info ?? session.info);
                 if (nextSnapshot.status === 'anonymous' && initializationErrorSnapshot?.status === 'error') {
                     return initializationErrorSnapshot;
@@ -131,9 +216,12 @@ export function createSolidSessionRuntime(options = {}) {
                 initialized = true;
                 return publish(nextSnapshot);
             })
-                .catch((error) => publish(snapshotFromSessionError(error, session.info)))
+                .catch((error) => isCurrentOperation()
+                ? publish(snapshotFromSessionError(error, session.info)) : snapshot)
                 .finally(() => {
                 if (initialization === nextInitialization) {
+                    if (pendingIdentity === operation)
+                        pendingIdentity = undefined;
                     initialization = undefined;
                     isInitializing = false;
                     initializationErrorSnapshot = undefined;
@@ -142,12 +230,46 @@ export function createSolidSessionRuntime(options = {}) {
             initialization = nextInitialization;
             return nextInitialization;
         },
-        login(options) {
-            return session.login(options);
+        async login(options) {
+            identityOperationGeneration += 1;
+            invalidateAuthentication();
+            authenticationOperations += 1;
+            try {
+                // Inrupt mutates one shared signer and emits untagged events. A new
+                // login cannot safely overlap a previous redirect. Fail promptly so
+                // callers can retry after it settles, or reload to obtain a new Session.
+                if (initialization) {
+                    const error = new Error('Previous login is still completing. Reload before reconnecting.');
+                    error.name = 'SolidSessionPendingError';
+                    throw error;
+                }
+                if (disposed)
+                    throw new Error('Solid session runtime is disposed');
+                await session.login(options);
+            }
+            catch (error) {
+                publish(snapshotFromSessionError(error, session.info));
+                throw error;
+            }
+            finally {
+                authenticationOperations -= 1;
+            }
         },
         async logout(options) {
-            await session.logout(options);
-            publish({ status: 'anonymous' });
+            identityOperationGeneration += 1;
+            invalidateAuthentication();
+            authenticationOperations += 1;
+            try {
+                await session.logout(options);
+                publish({ status: 'anonymous' });
+            }
+            catch (error) {
+                publish(snapshotFromSessionError(error, session.info));
+                throw error;
+            }
+            finally {
+                authenticationOperations -= 1;
+            }
         },
         subscribe(listener) {
             listeners.add(listener);
@@ -156,6 +278,8 @@ export function createSolidSessionRuntime(options = {}) {
             };
         },
         dispose() {
+            identityOperationGeneration += 1;
+            invalidateAuthentication();
             disposed = true;
             listeners.clear();
             session.events.off(EVENTS.LOGIN, publishSessionInfo);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@undefineds.co/xpod",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Xpod is an extended Community Solid Server, offering rich-feature, production-level Solid Pod and identity management.",
   "repository": "https://github.com/undefinedsco/xpod",
   "author": "developer@undefineds.co",
@@ -342,6 +342,12 @@
     "abort-controller": "^3.0.0",
     "process": "^0.11.10",
     "string_decoder": "^1.3.0",
+    "@undefineds.co/drizzle-solid": "file:./node_modules/@undefineds.co/drizzle-solid",
+    "@undefineds.co/extensions": "file:./node_modules/@undefineds.co/extensions",
+    "@undefineds.co/ai-connections": "file:./node_modules/@undefineds.co/ai-connections",
+    "@undefineds.co/extension-sdk": "file:./node_modules/@undefineds.co/extension-sdk",
+    "@undefineds.co/shared-ui": "file:./node_modules/@undefineds.co/shared-ui",
+    "@undefineds.co/solid-sdk": "file:./node_modules/@undefineds.co/solid-sdk",
     "oidc-provider": "9.5.1",
     "@inrupt/solid-client-authn-browser": "3.1.1",
     "jose": "5.10.0",
@@ -370,7 +376,7 @@
     }
   },
   "optionalDependencies": {
-    "@undefineds.co/xpod-darwin-arm64": "0.4.8"
+    "@undefineds.co/xpod-darwin-arm64": "0.4.10"
   },
   "resolutions": {
     "@inrupt/solid-client-authn-browser": "^3.1.1",