@mdbase-dev/connect 0.1.0-beta.31 → 0.1.0-beta.33

package/dist/connection-notifications.js

@@ -1,17 +1,21 @@
 import { connectError } from "./errors.js";
-import { apiError, connectFetch, parseStored } from "./runtime-utils.js";
+import { apiError, connectFetch, decodeJsonResponse, parseStored } from "./runtime-utils.js";
 import { base64UrlBytes, randomBase64Url } from "./base64.js";
+import { withRequestBudget } from "./request-budget.js";
 export class ConnectionNotifications {
     context;
     constructor(context) {
         this.context = context;
     }
     async registerNotifications(options) {
-        const token = await this.context.authorizedToken();
+        return withRequestBudget(options, this.context.requestTimeoutMs, (budget) => this.registerNotificationsWithinBudget(options, budget.signal));
+    }
+    async registerNotificationsWithinBudget(options, signal) {
+        const token = await this.context.authorizedToken(signal);
         if (!token) {
             throw connectError("not_authorized", "Connect this application before enabling notifications.");
         }
-        const application = await this.context.register();
+        const application = await this.context.register(signal);
         const declared = application.notifications?.criteria.map((criterion) => criterion.id) ?? [];
         const criteria = [...new Set(options.criteria ?? declared)];
         const undeclared = criteria.find((criterion) => !declared.includes(criterion));
@@ -21,8 +25,8 @@ export class ConnectionNotifications {
         if (criteria.length === 0) {
             throw connectError("notifications_not_declared", "This application manifest does not declare any notification criteria.");
         }
-        const keyResponse = await connectFetch(`${this.context.serverUrl}/v1/notifications/vapid-public-key`, undefined, "notifications_unavailable", "Push notifications are unavailable.");
-        const keyBody = await keyResponse.json();
+        const keyResponse = await connectFetch(`${this.context.serverUrl}/v1/notifications/vapid-public-key`, { signal }, "notifications_unavailable", "Push notifications are unavailable.");
+        const keyBody = await decodeJsonResponse(keyResponse, "invalid_operation_response", "Connect returned an invalid notification key response.");
         if (!keyResponse.ok) {
             throw apiError(keyBody, "notifications_unavailable", "Push notifications are unavailable.", keyResponse.status);
         }
@@ -55,16 +59,18 @@ export class ConnectionNotifications {
                     expirationTime: serialized.expirationTime ?? null,
                     keys: serialized.keys
                 }
-            })
+            }),
+            signal
         }, "notification_registration_failed", "Could not register push notifications.");
-        const channelBody = await channelResponse.json();
+        const channelBody = await decodeJsonResponse(channelResponse, "invalid_operation_response", "Connect returned an invalid notification registration response.");
         if (!channelResponse.ok) {
             throw apiError(channelBody, "notification_registration_failed", "Could not register push notifications.", channelResponse.status);
         }
         if (previous?.channelId && previous.channelId !== channelBody.channel_id) {
             void fetch(`${this.context.serverUrl}/v1/notifications/channels/${previous.channelId}`, {
                 method: "DELETE",
-                headers: { authorization: `Bearer ${token.accessToken}` }
+                headers: { authorization: `Bearer ${token.accessToken}` },
+                signal
             }).catch(() => undefined);
         }
         const registration = {
@@ -82,11 +88,14 @@ export class ConnectionNotifications {
      * same installation whenever Firebase refreshes its token.
      */
     async registerNativeNotifications(options) {
-        const token = await this.context.authorizedToken();
+        return withRequestBudget(options, this.context.requestTimeoutMs, (budget) => this.registerNativeNotificationsWithinBudget(options, budget.signal));
+    }
+    async registerNativeNotificationsWithinBudget(options, signal) {
+        const token = await this.context.authorizedToken(signal);
         if (!token) {
             throw connectError("not_authorized", "Connect this application before enabling notifications.");
         }
-        const application = await this.context.register();
+        const application = await this.context.register(signal);
         if (application.notifications?.native_delivery?.mode !== "managed_fcm") {
             throw connectError("managed_fcm_not_declared", "This application does not declare Connect-managed native notifications.");
         }
@@ -115,14 +124,15 @@ export class ConnectionNotifications {
                 criteria,
                 transport: "fcm",
                 token: options.token
-            })
+            }),
+            signal
         }, "notification_registration_failed", "Could not register native notifications.");
-        const body = await response.json();
+        const body = await decodeJsonResponse(response, "invalid_operation_response", "Connect returned an invalid native notification response.");
         if (!response.ok) {
             throw apiError(body, "notification_registration_failed", "Could not register native notifications.", response.status);
         }
         if (previous?.channelId && previous.channelId !== body.channel_id) {
-            void this.deleteNotificationChannel(previous.channelId, token.accessToken)
+            void this.deleteNotificationChannel(previous.channelId, token.accessToken, signal)
                 .catch(() => undefined);
         }
         const registration = {
@@ -134,31 +144,38 @@ export class ConnectionNotifications {
         this.context.storage.setItem(storageKey, JSON.stringify(registration));
         return registration;
     }
-    async unregisterNativeNotifications() {
+    async unregisterNativeNotifications(options = {}) {
+        return withRequestBudget(options, this.context.requestTimeoutMs, (budget) => this.unregisterNativeNotificationsWithinBudget(budget.signal));
+    }
+    async unregisterNativeNotificationsWithinBudget(signal) {
         const storageKey = this.context.notificationKey("fcm");
         const registration = parseStored(this.context.storage.getItem(storageKey));
-        const token = await this.context.authorizedToken();
+        const token = await this.context.authorizedToken(signal);
         if (registration?.channelId && !token) {
             throw connectError("not_authorized", "Reconnect this application before disabling native notifications.");
         }
         if (registration?.channelId && token) {
-            await this.deleteNotificationChannel(registration.channelId, token.accessToken);
+            await this.deleteNotificationChannel(registration.channelId, token.accessToken, signal);
         }
         this.context.storage.removeItem(storageKey);
     }
-    async unregisterNotifications(serviceWorker) {
+    async unregisterNotifications(serviceWorker, options = {}) {
+        return withRequestBudget(options, this.context.requestTimeoutMs, (budget) => this.unregisterNotificationsWithinBudget(serviceWorker, budget.signal));
+    }
+    async unregisterNotificationsWithinBudget(serviceWorker, signal) {
         const registration = parseStored(this.context.storage.getItem(this.context.notificationKey()));
-        const token = await this.context.authorizedToken();
+        const token = await this.context.authorizedToken(signal);
         if (registration?.channelId && !token) {
             throw connectError("not_authorized", "Reconnect this application before disabling push notifications.");
         }
         if (registration?.channelId && token) {
             const response = await connectFetch(`${this.context.serverUrl}/v1/notifications/channels/${registration.channelId}`, {
                 method: "DELETE",
-                headers: { authorization: `Bearer ${token.accessToken}` }
+                headers: { authorization: `Bearer ${token.accessToken}` },
+                signal
             }, "notification_unregistration_failed", "Could not unregister push notifications.");
             if (!response.ok && response.status !== 404) {
-                const body = await response.json();
+                const body = await decodeJsonResponse(response, "invalid_operation_response", "Connect returned an invalid notification response.");
                 throw apiError(body, "notification_unregistration_failed", "Could not unregister push notifications.", response.status);
             }
         }
@@ -166,13 +183,14 @@ export class ConnectionNotifications {
         const subscription = await serviceWorker?.pushManager.getSubscription();
         await subscription?.unsubscribe();
     }
-    async deleteNotificationChannel(channelId, accessToken) {
+    async deleteNotificationChannel(channelId, accessToken, signal) {
         const response = await connectFetch(`${this.context.serverUrl}/v1/notifications/channels/${channelId}`, {
             method: "DELETE",
-            headers: { authorization: `Bearer ${accessToken}` }
+            headers: { authorization: `Bearer ${accessToken}` },
+            signal
         }, "notification_unregistration_failed", "Could not unregister push notifications.");
         if (!response.ok && response.status !== 404) {
-            const body = await response.json();
+            const body = await decodeJsonResponse(response, "invalid_operation_response", "Connect returned an invalid notification response.");
             throw apiError(body, "notification_unregistration_failed", "Could not unregister push notifications.", response.status);
         }
     }

package/dist/connection-transport.d.ts

@@ -2,14 +2,14 @@ import type { CollectionOperation } from "@mdbase-dev/connect-protocol";
 import { type GrantKeyStore } from "./crypto.js";
 import type { StoredToken } from "./internal-types.js";
 import type { DirectAccessStatus, MdbaseConnectionRoute } from "./connection-types.js";
-import type { OperationRequestOptions, PendingMutationSummary } from "./operation-types.js";
+import type { ConnectRequestOptions, PendingMutationSummary } from "./operation-types.js";
 import { ConnectionFileTransport } from "./connection-file-transport.js";
+import { type ResolvedConnectTimeouts } from "./request-budget.js";
 export interface ConnectionTransportInternals {
     readonly relayEncryption: "required" | "disabled";
-    removeToken(collectionId: string, keyHandle?: string, reason?: "not_authorized" | "authorization_lost" | "invalid_stored_grant"): void;
+    removeToken(collectionId: string, keyHandle?: string, reason?: "not_authorized" | "authorization_lost" | "invalid_stored_grant", discardPending?: boolean): void;
     storeTokenResponse(body: any, clientId: string, keyHandle?: string): StoredToken;
     tokenKey(collectionId: string): string;
-    notificationKey(collectionId: string, transport?: "web_push" | "fcm"): string;
     pendingMutationKey(collectionId: string): string;
     directPreferenceKey(): string;
 }
@@ -22,6 +22,7 @@ export interface ConnectionTransportOptions {
     collectionId: string;
     internals: ConnectionTransportInternals;
     onChange(): void;
+    timeouts: ResolvedConnectTimeouts;
 }
 export declare class ConnectionTransport {
     private readonly serverUrl;
@@ -32,6 +33,8 @@ export declare class ConnectionTransport {
     private readonly collectionId;
     private readonly internals;
     private readonly onChange;
+    private readonly timeouts;
+    private readonly pendingMutationStore;
     readonly files: ConnectionFileTransport;
     private refreshPromise;
     private directStatus;
@@ -42,19 +45,23 @@ export declare class ConnectionTransport {
     get directAccess(): DirectAccessStatus;
     get route(): MdbaseConnectionRoute;
     notifyStorageChanged(): void;
-    checkDirectAccess(): Promise<DirectAccessStatus>;
+    checkDirectAccess(options?: ConnectRequestOptions): Promise<DirectAccessStatus>;
+    private checkDirectAccessWithinBudget;
     /** Call from a user gesture to request browser permission for direct local access. */
-    requestDirectAccess(): Promise<DirectAccessStatus>;
+    requestDirectAccess(options?: ConnectRequestOptions): Promise<DirectAccessStatus>;
+    private requestDirectAccessWithinBudget;
     disableDirectAccess(): void;
     /**
      * Return one offline-replication transport regardless of whether the
      * authority is remote, directly connected, or relay connected.
      * Authority credentials and routing stay private inside the SDK.
      */
-    pendingMutation(): PendingMutationSummary | null;
-    resumePendingMutation<Result>(input: unknown, options?: OperationRequestOptions): Promise<Result>;
-    performOperation<Result>(operation: CollectionOperation, input: unknown, options?: OperationRequestOptions): Promise<Result>;
-    performAuthoritySyncRequest<Result>(collectionId: string, replicaId: string, method: "GET" | "POST", path: string, input?: unknown): Promise<Result>;
+    pendingMutations(): readonly PendingMutationSummary[];
+    pendingMutation(requestId: string): PendingMutationSummary | null;
+    recoverPendingMutation<Result>(requestId: string, options?: ConnectRequestOptions): Promise<Result>;
+    performOperation<Result>(operation: CollectionOperation, input: unknown, options?: ConnectRequestOptions): Promise<Result>;
+    private performOperationWithinBudget;
+    performAuthoritySyncRequest<Result>(collectionId: string, replicaId: string, method: "GET" | "POST", path: string, input?: unknown, options?: ConnectRequestOptions): Promise<Result>;
     private sendAuthoritySyncRequest;
     private sendOperation;
     private directCapable;
@@ -69,14 +76,11 @@ export declare class ConnectionTransport {
     private emitConnection;
     private invalidateRejectedAuthorization;
     currentToken(): StoredToken | null;
-    authorizedToken(): Promise<StoredToken | null>;
+    authorizedToken(options?: ConnectRequestOptions): Promise<StoredToken | null>;
     private refreshAuthorization;
     private performRefresh;
-    private authorityProofHeaders;
     private storeTokenResponse;
-    private tokenKey;
-    private notificationKey;
-    private pendingMutationKey;
+    private storedPendingMutations;
+    private storedPendingMutation;
     private clearPendingMutation;
-    private directPreferenceKey;
 }