@mdbase-dev/connect 0.1.0-beta.21

package/dist/connection-notifications.js

@@ -0,0 +1,179 @@
+import { MdbaseConnectError } from "./errors.js";
+import { apiError, parseStored } from "./runtime-utils.js";
+import { base64UrlBytes, randomBase64Url } from "./base64.js";
+export class ConnectionNotifications {
+    context;
+    constructor(context) {
+        this.context = context;
+    }
+    async registerNotifications(options) {
+        const token = await this.context.authorizedToken();
+        if (!token) {
+            throw new MdbaseConnectError("not_authorized", "Connect this application before enabling notifications.");
+        }
+        const application = await this.context.register();
+        const declared = application.notifications?.criteria.map((criterion) => criterion.id) ?? [];
+        const criteria = [...new Set(options.criteria ?? declared)];
+        const undeclared = criteria.find((criterion) => !declared.includes(criterion));
+        if (undeclared) {
+            throw new MdbaseConnectError("notification_criterion_not_declared", `The application manifest does not declare notification criterion ${undeclared}.`);
+        }
+        if (criteria.length === 0) {
+            throw new MdbaseConnectError("notifications_not_declared", "This application manifest does not declare any notification criteria.");
+        }
+        const keyResponse = await fetch(`${this.context.serverUrl}/v1/notifications/vapid-public-key`);
+        const keyBody = await keyResponse.json();
+        if (!keyResponse.ok) {
+            throw apiError(keyBody, "notifications_unavailable", "Push notifications are unavailable.", keyResponse.status);
+        }
+        let pushSubscription = await options.serviceWorker.pushManager.getSubscription();
+        if (!pushSubscription) {
+            pushSubscription = await options.serviceWorker.pushManager.subscribe({
+                userVisibleOnly: true,
+                applicationServerKey: base64UrlBytes(keyBody.public_key)
+            });
+        }
+        const serialized = pushSubscription.toJSON();
+        if (!serialized.endpoint || !serialized.keys?.p256dh || !serialized.keys.auth) {
+            throw new MdbaseConnectError("invalid_push_subscription", "The browser returned an incomplete push subscription.");
+        }
+        const previous = parseStored(this.context.storage.getItem(this.context.notificationKey()));
+        const installationId = options.installationId
+            ?? previous?.installationId
+            ?? randomBase64Url(24);
+        const channelResponse = await fetch(`${this.context.serverUrl}/v1/notifications/channels`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${token.accessToken}`,
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({
+                installation_id: installationId,
+                criteria,
+                subscription: {
+                    endpoint: serialized.endpoint,
+                    expirationTime: serialized.expirationTime ?? null,
+                    keys: serialized.keys
+                }
+            })
+        });
+        const channelBody = await channelResponse.json();
+        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}` }
+            }).catch(() => undefined);
+        }
+        const registration = {
+            channelId: channelBody.channel_id,
+            installationId,
+            criteria
+        };
+        this.context.storage.setItem(this.context.notificationKey(), JSON.stringify(registration));
+        return registration;
+    }
+    /**
+     * Register an iOS or Android installation for Connect-managed FCM.
+     *
+     * The application manifest selects the Firebase project. Re-register the
+     * same installation whenever Firebase refreshes its token.
+     */
+    async registerNativeNotifications(options) {
+        const token = await this.context.authorizedToken();
+        if (!token) {
+            throw new MdbaseConnectError("not_authorized", "Connect this application before enabling notifications.");
+        }
+        const application = await this.context.register();
+        if (application.notifications?.native_delivery?.mode !== "managed_fcm") {
+            throw new MdbaseConnectError("managed_fcm_not_declared", "This application does not declare Connect-managed native notifications.");
+        }
+        const declared = application.notifications.criteria.map((criterion) => criterion.id);
+        const criteria = [...new Set(options.criteria ?? declared)];
+        const undeclared = criteria.find((criterion) => !declared.includes(criterion));
+        if (undeclared) {
+            throw new MdbaseConnectError("notification_criterion_not_declared", `The application manifest does not declare notification criterion ${undeclared}.`);
+        }
+        if (criteria.length === 0) {
+            throw new MdbaseConnectError("notifications_not_declared", "This application manifest does not declare any notification criteria.");
+        }
+        const storageKey = this.context.notificationKey("fcm");
+        const previous = parseStored(this.context.storage.getItem(storageKey));
+        const installationId = options.installationId
+            ?? previous?.installationId
+            ?? randomBase64Url(24);
+        const response = await fetch(`${this.context.serverUrl}/v1/notifications/channels`, {
+            method: "POST",
+            headers: {
+                authorization: `Bearer ${token.accessToken}`,
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({
+                installation_id: installationId,
+                criteria,
+                transport: "fcm",
+                token: options.token
+            })
+        });
+        const body = await response.json();
+        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)
+                .catch(() => undefined);
+        }
+        const registration = {
+            channelId: body.channel_id,
+            installationId,
+            transport: "fcm",
+            criteria
+        };
+        this.context.storage.setItem(storageKey, JSON.stringify(registration));
+        return registration;
+    }
+    async unregisterNativeNotifications() {
+        const storageKey = this.context.notificationKey("fcm");
+        const registration = parseStored(this.context.storage.getItem(storageKey));
+        const token = await this.context.authorizedToken();
+        if (registration?.channelId && !token) {
+            throw new MdbaseConnectError("not_authorized", "Reconnect this application before disabling native notifications.");
+        }
+        if (registration?.channelId && token) {
+            await this.deleteNotificationChannel(registration.channelId, token.accessToken);
+        }
+        this.context.storage.removeItem(storageKey);
+    }
+    async unregisterNotifications(serviceWorker) {
+        const registration = parseStored(this.context.storage.getItem(this.context.notificationKey()));
+        const token = await this.context.authorizedToken();
+        if (registration?.channelId && !token) {
+            throw new MdbaseConnectError("not_authorized", "Reconnect this application before disabling push notifications.");
+        }
+        if (registration?.channelId && token) {
+            const response = await fetch(`${this.context.serverUrl}/v1/notifications/channels/${registration.channelId}`, {
+                method: "DELETE",
+                headers: { authorization: `Bearer ${token.accessToken}` }
+            });
+            if (!response.ok && response.status !== 404) {
+                const body = await response.json();
+                throw apiError(body, "notification_unregistration_failed", "Could not unregister push notifications.", response.status);
+            }
+        }
+        this.context.storage.removeItem(this.context.notificationKey());
+        const subscription = await serviceWorker?.pushManager.getSubscription();
+        await subscription?.unsubscribe();
+    }
+    async deleteNotificationChannel(channelId, accessToken) {
+        const response = await fetch(`${this.context.serverUrl}/v1/notifications/channels/${channelId}`, {
+            method: "DELETE",
+            headers: { authorization: `Bearer ${accessToken}` }
+        });
+        if (!response.ok && response.status !== 404) {
+            const body = await response.json();
+            throw apiError(body, "notification_unregistration_failed", "Could not unregister push notifications.", response.status);
+        }
+    }
+}

package/dist/connection-transport.d.ts

@@ -0,0 +1,80 @@
+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";
+export interface ConnectionTransportInternals {
+    readonly relayEncryption: "required" | "disabled";
+    removeToken(collectionId: string, keyHandle?: string, reason?: "not_authorized" | "authorization_lost" | "invalid_stored_grant"): 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;
+}
+export interface ConnectionTransportOptions {
+    serverUrl: string;
+    storage: Storage;
+    keyStore: GrantKeyStore;
+    directAccessMode: "auto" | "disabled";
+    loopbackUrl: string;
+    collectionId: string;
+    internals: ConnectionTransportInternals;
+    onChange(): void;
+}
+export declare class ConnectionTransport {
+    private readonly serverUrl;
+    private readonly storage;
+    private readonly keyStore;
+    private readonly directAccessMode;
+    private readonly loopbackUrl;
+    private readonly collectionId;
+    private readonly internals;
+    private readonly onChange;
+    private refreshPromise;
+    private directStatus;
+    private currentRoute;
+    private directFailures;
+    private directRetryAt;
+    constructor(options: ConnectionTransportOptions);
+    get directAccess(): DirectAccessStatus;
+    get route(): MdbaseConnectionRoute;
+    notifyStorageChanged(): void;
+    checkDirectAccess(): Promise<DirectAccessStatus>;
+    /** Call from a user gesture to request browser permission for direct local access. */
+    requestDirectAccess(): Promise<DirectAccessStatus>;
+    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>;
+    private sendAuthoritySyncRequest;
+    private sendOperation;
+    private directCapable;
+    hasResumableMutationTransport(): boolean;
+    private directEligible;
+    private shouldAttemptDirect;
+    private probeDirectAccess;
+    private markDirectAvailable;
+    private markDirectUnavailable;
+    private setDirectStatus;
+    private setRoute;
+    private emitConnection;
+    private invalidateRejectedAuthorization;
+    currentToken(): StoredToken | null;
+    authorizedToken(): Promise<StoredToken | null>;
+    private refreshAuthorization;
+    private performRefresh;
+    private authorityProofHeaders;
+    private storeTokenResponse;
+    private tokenKey;
+    private notificationKey;
+    private pendingMutationKey;
+    private clearPendingMutation;
+    private directPreferenceKey;
+}