@undefineds.co/xpod 0.4.9 → 0.4.11

package/dist/identity/drizzle/db.js

@@ -36,6 +36,10 @@ exports.executePostgresLockedStatements = executePostgresLockedStatements;
 exports.ensureCloudClusterTables = ensureCloudClusterTables;
 exports.toDbTimestamp = toDbTimestamp;
 exports.fromDbTimestamp = fromDbTimestamp;
+exports.jsonFieldExtract = jsonFieldExtract;
+exports.jsonFieldEquals = jsonFieldEquals;
+exports.jsonFieldIn = jsonFieldIn;
+exports.jsonFieldIsPrefixOf = jsonFieldIsPrefixOf;
 const pg_1 = require("pg");
 const node_postgres_1 = require("drizzle-orm/node-postgres");
 const drizzle_orm_1 = require("drizzle-orm");
@@ -425,6 +429,41 @@ function fromDbTimestamp(value) {
     }
     return undefined;
 }
+function jsonFieldPath(field) {
+    return `$."${field.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+/**
+ * `payload` JSON 字段提取表达式，按方言生成（SQLite json_extract / PG ->>）。
+ * alias 用于 join 场景下限定来源表。
+ */
+function jsonFieldExtract(db, field, alias) {
+    const target = alias ? (0, drizzle_orm_1.sql) `${drizzle_orm_1.sql.identifier(alias)}.payload` : (0, drizzle_orm_1.sql) `payload`;
+    if (isDatabaseSqlite(db)) {
+        return (0, drizzle_orm_1.sql) `json_extract(${target}, ${jsonFieldPath(field)})`;
+    }
+    return (0, drizzle_orm_1.sql) `${target} ->> ${field}`;
+}
+/**
+ * `payload` 字段等于标量值的方言条件。
+ */
+function jsonFieldEquals(db, field, value, alias) {
+    return (0, drizzle_orm_1.sql) `${jsonFieldExtract(db, field, alias)} = ${value}`;
+}
+/**
+ * `payload` 字段落在值集合内的方言条件。values 为空时调用方应跳过查询。
+ */
+function jsonFieldIn(db, field, values, alias) {
+    const list = drizzle_orm_1.sql.join(values.map((value) => (0, drizzle_orm_1.sql) `${value}`), (0, drizzle_orm_1.sql) `, `);
+    return (0, drizzle_orm_1.sql) `${jsonFieldExtract(db, field, alias)} IN (${list})`;
+}
+/**
+ * 反向前缀匹配：`value LIKE payload->field || '%'`。
+ * 用于"资源 URL 以存储的 baseUrl 为前缀"的下推预筛；存储值中的 LIKE 元字符只会多匹配，
+ * 调用方需在 JS 侧用 startsWith 复核，不会漏匹配。
+ */
+function jsonFieldIsPrefixOf(db, field, value, alias) {
+    return (0, drizzle_orm_1.sql) `${value} LIKE (${jsonFieldExtract(db, field, alias)}) || '%'`;
+}
 /**
  * Ensure SQLite tables exist (simple DDL for local/dev mode).
  */
@@ -520,9 +559,5 @@ async function ensurePostgresTables(pool) {
     );
 
   `);
-    await migratePostgresColumns(pool);
-}
-async function migratePostgresColumns(pool) {
-    void pool;
 }
 //# sourceMappingURL=db.js.map

package/node_modules/@undefineds.co/ai-connections/dist/AiConnectionsMain.js

@@ -31,6 +31,7 @@ export function AiConnectionsMain({ controller, renderToaster = true }) {
     useEffect(() => {
         if (controller.client)
             void controller.loadProviders();
+        return () => controller.cancelProviderLoads();
     }, [controller]);
     if (!controller.client) {
         return (_jsxs("section", { role: "alert", "aria-label": "AI Connections unavailable", children: [_jsx("h2", { children: "AI Connections \u5C1A\u672A\u5C31\u7EEA" }), _jsx("p", { children: "\u5BBF\u4E3B\u9700\u8981\u5148\u63D0\u4F9B\u5DF2\u767B\u5F55\u7684 WebID \u548C\u53EF\u7528\u7684 Pod\u3002" })] }));

package/node_modules/@undefineds.co/ai-connections/dist/controller.d.ts

@@ -38,6 +38,7 @@ export interface AiConnectionsController {
     setSearchQuery(value: string): void;
     setProviderState(provider: AiConnectionsProvider, state: ProviderProductState): void;
     loadProviders(): Promise<void>;
+    cancelProviderLoads(): void;
     subscribe(listener: () => void): () => void;
 }
 export declare function createAiConnectionsController(host: WebExtensionHost): AiConnectionsController;

package/node_modules/@undefineds.co/ai-connections/dist/controller.js

@@ -16,18 +16,72 @@ export const AI_CONNECTIONS_PINNED_SECTIONS = [
 if (PROVIDERS.map((provider) => provider.id).join(',') !== AI_CONNECTIONS_PROVIDERS.join(',')) {
     throw new Error('AI Connection provider UI is out of sync with the client catalog');
 }
+class ProviderLoadCancelled extends Error {
+}
 export function createAiConnectionsController(host) {
     const sessionSnapshot = host.solid.session.getSnapshot();
     const pod = host.solid.pod;
     const readyPod = pod?.status === 'ready' ? pod : undefined;
     const authenticated = sessionSnapshot.status === 'authenticated'
         && readyPod !== undefined;
+    let providerLoadGeneration = 0;
+    let providerLoadPromise;
+    let providerLoadOperation;
+    const activeProviderLoads = new Set();
+    const isCurrentSession = () => {
+        const current = host.solid.session.getSnapshot();
+        return authenticated && current.status === 'authenticated' && current.webId === sessionSnapshot.webId;
+    };
+    const cancelProviderLoads = () => {
+        providerLoadGeneration += 1;
+        providerLoadOperation = undefined;
+        providerLoadPromise = undefined;
+        for (const guard of activeProviderLoads)
+            guard.cancel();
+    };
+    const beginProviderLoad = () => {
+        const generation = providerLoadGeneration;
+        let invalidated = !isCurrentSession();
+        let released = false;
+        let unsubscribe = () => undefined;
+        const guard = {
+            assertCurrent() {
+                if (invalidated || generation !== providerLoadGeneration || !isCurrentSession())
+                    throw new ProviderLoadCancelled();
+            },
+            dispose() {
+                if (released)
+                    return;
+                released = true;
+                activeProviderLoads.delete(guard);
+                unsubscribe();
+            },
+            cancel() {
+                invalidated = true;
+                guard.dispose();
+            },
+        };
+        activeProviderLoads.add(guard);
+        let subscribing = true;
+        unsubscribe = host.solid.session.subscribe((current) => {
+            // The Solid SDK deduplicates unchanged state except new LOGIN/RESTORED
+            // sessions; SESSION_EXTENDED does not notify. Accept a synchronous initial
+            // snapshot, then invalidate on every published session transition.
+            if (!subscribing || current.status !== 'authenticated' || current.webId !== sessionSnapshot.webId)
+                cancelProviderLoads();
+        });
+        subscribing = false;
+        // Also handle a host that synchronously publishes its state on subscribe.
+        if (released)
+            unsubscribe();
+        return guard;
+    };
     const client = authenticated
         ? createInteractiveAiConnectionsClient(withAccountClientCredentials(createAiConnectionsClient({
             webId: sessionSnapshot.webId,
             podBaseUrl: readyPod.current.podUrl,
             authenticatedFetch: host.solid.session.fetch,
-        }), host.capabilities.aiClientCredentials), host.capabilities.aiConnectionsPodStore)
+        }), host.capabilities.aiClientCredentials), host.capabilities.aiConnectionsPodStore, beginProviderLoad)
         : null;
     let selectedSection = 'keys';
     let selectedProvider = 'openai';
@@ -36,8 +90,6 @@ export function createAiConnectionsController(host) {
     let providerStates = {};
     let providerSummaries = {};
     let providerLoadError;
-    let providerLoadGeneration = 0;
-    let providerLoadPromise;
     const listeners = new Set();
     const notify = () => listeners.forEach((listener) => listener());
     const controller = {
@@ -111,19 +163,23 @@ export function createAiConnectionsController(host) {
             }
             notify();
         },
+        cancelProviderLoads,
         async loadProviders() {
             if (!client)
                 return;
             if (providerLoadPromise)
                 return providerLoadPromise;
-            providerLoadPromise = (async () => {
-                const generation = providerLoadGeneration + 1;
-                providerLoadGeneration = generation;
+            const operation = {};
+            providerLoadOperation = operation;
+            const generation = ++providerLoadGeneration;
+            const load = Promise.resolve().then(async () => {
+                if (providerLoadOperation !== operation)
+                    return;
                 providerLoadError = undefined;
                 notify();
                 try {
                     const summaries = await client.listProviders();
-                    if (generation !== providerLoadGeneration)
+                    if (generation !== providerLoadGeneration || !isCurrentSession())
                         return;
                     providerSummaries = Object.fromEntries(summaries.map((summary) => [summary.id, summary]));
                     providerStates = Object.fromEntries(PROVIDERS.map((provider) => [
@@ -133,16 +189,20 @@ export function createAiConnectionsController(host) {
                     notify();
                 }
                 catch (error) {
-                    if (generation !== providerLoadGeneration)
+                    if (error instanceof ProviderLoadCancelled || generation !== providerLoadGeneration || !isCurrentSession())
                         return;
                     providerLoadError = errorMessage(error);
                     notify();
                 }
                 finally {
-                    providerLoadPromise = undefined;
+                    if (providerLoadOperation === operation) {
+                        providerLoadOperation = undefined;
+                        providerLoadPromise = undefined;
+                    }
                 }
-            })();
-            return providerLoadPromise;
+            });
+            providerLoadPromise = load;
+            return load;
         },
         subscribe(listener) {
             listeners.add(listener);
@@ -195,9 +255,29 @@ function withAccountClientCredentials(client, credentials) {
         },
     };
 }
-function createInteractiveAiConnectionsClient(operationsClient, podStore) {
+function createInteractiveAiConnectionsClient(operationsClient, podStore, beginProviderLoad) {
+    const listProviders = async () => {
+        const guard = beginProviderLoad();
+        try {
+            guard.assertCurrent();
+            const providers = podStore
+                ? await podStore.listProviders()
+                : await operationsClient.listProviders();
+            guard.assertCurrent();
+            if (!podStore)
+                return providers;
+            const methods = operationsClient.listAuthorizationMethods
+                ? await operationsClient.listAuthorizationMethods()
+                : [];
+            guard.assertCurrent();
+            return mergeAuthorizationMethodsIntoProviders(providers, methods);
+        }
+        finally {
+            guard.dispose();
+        }
+    };
     if (!podStore)
-        return operationsClient;
+        return { ...operationsClient, listProviders };
     const refreshTasks = new Map();
     const refreshOAuthCredential = podStore.readCredentialSecret && podStore.updateOAuthCredential
         ? (provider, credentialId) => {
@@ -249,9 +329,7 @@ function createInteractiveAiConnectionsClient(operationsClient, podStore) {
     };
     return {
         ...operationsClient,
-        listProviders: async () => mergeAuthorizationMethodsIntoProviders(await podStore.listProviders(), operationsClient.listAuthorizationMethods
-            ? await operationsClient.listAuthorizationMethods()
-            : []),
+        listProviders,
         listModels: podStore.listModels
             ? async () => podStore.listModels()
             : operationsClient.listModels,

package/node_modules/@undefineds.co/shared-ui/dist/index.d.ts

@@ -17,7 +17,6 @@ export { LocalReachabilitySummary, } from './login/LocalReachabilitySummary';
 export { getProviderActionLabel, getProviderDisplayLabel, getProviderInfoText, getProviderSourceLabel, getProviderStatusBadge, getProviderSubtitle, type ProviderStatusBadge, } from './login/presentation';
 export { isLocalLoginProvider, isLocalLoginProviderSource, resolveLoginProviderSource, } from './login/provider-model';
 export type { AuthWindowStatus, ConnectingProviderInfo, LocalLoginProviderSource, LocalLoginStatus, LocalOnboardingCapabilities, LocalOnboardingConnectivity, LocalOnboardingProgress, LocalOnboardingRouteKind, LocalOnboardingRouteProbe, LocalOnboardingSnapshot, LocalOnboardingState, LocalOnboardingTunnel, LocalPodRuntime, LocalSpaceKind, LoginEndpoint, LoginEndpointKind, LoginModalProps, LoginProviderOption, LoginProviderSource, LoginState, ProviderOption, StorageConflict, StoredAccount, } from './login/types';
-export * from './oidc-consent';
 export * from './scroll-area';
 export * from './separator';
 export * from './skeleton';

package/node_modules/@undefineds.co/shared-ui/dist/index.js

@@ -16,7 +16,6 @@ export { LoginView, } from './login/LoginView.js';
 export { LocalReachabilitySummary, } from './login/LocalReachabilitySummary.js';
 export { getProviderActionLabel, getProviderDisplayLabel, getProviderInfoText, getProviderSourceLabel, getProviderStatusBadge, getProviderSubtitle, } from './login/presentation.js';
 export { isLocalLoginProvider, isLocalLoginProviderSource, resolveLoginProviderSource, } from './login/provider-model.js';
-export * from './oidc-consent.js';
 export * from './scroll-area.js';
 export * from './separator.js';
 export * from './skeleton.js';

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;