@mdbase-dev/connect 0.1.0-beta.100

package/dist/connect-authorization-helpers.js

@@ -0,0 +1,25 @@
+import { APPLICATION_AUTHORIZATION_V2_ISSUANCE_CAPABILITY } from "@mdbase-dev/connect-protocol";
+import { MdbaseConnectError, connectError } from "./errors.js";
+export async function assertFreshV2AuthorizationSupport(serverUrl, signal) {
+    const response = await fetch(`${serverUrl}/health`, { signal, cache: "no-store" });
+    const health = await response.json().catch(() => null);
+    if (!response.ok || !Array.isArray(health?.capabilities)
+        || !health.capabilities.every((value) => typeof value === "string")
+        || !health.capabilities.includes(APPLICATION_AUTHORIZATION_V2_ISSUANCE_CAPABILITY)) {
+        throw connectError("capability_contract_incompatible", "This server does not support new version-2 application authorizations.", {
+            details: { contract: "fresh_application_authorization", required: [2], supported: [], peer: "server" }
+        });
+    }
+}
+export function declarationIdFromFamilyIdentity(familyIdentity) {
+    const prefix = "bundle:";
+    if (!familyIdentity.startsWith(prefix) || familyIdentity.length === prefix.length) {
+        throw new Error("The registered application has no valid declaration identity.");
+    }
+    return familyIdentity.slice(prefix.length);
+}
+export function authorizationAbort(signal, message, cause) {
+    if (signal.reason instanceof MdbaseConnectError)
+        return signal.reason;
+    return connectError("authorization_cancelled", message, { cause });
+}

package/dist/connect-options.d.ts

@@ -0,0 +1,35 @@
+import type { MdbaseApplicationManifest as MdbaseAppManifest } from "./application-contract.js";
+import type { JsonObject } from "@mdbase-dev/connect-protocol";
+import type { GrantKeyStore } from "./crypto.js";
+import type { ApplicationIdentityStore } from "./application-identity.js";
+export interface MdbaseConnectTimeouts {
+    requestMs?: number | null;
+    watchStartMs?: number | null;
+    fileIndexMs?: number | null;
+    uploadMs?: number | null;
+    syncMs?: number | null;
+}
+export interface MdbaseConnectOptions {
+    serverUrl: string | URL;
+    /**
+     * A bundled v1 application manifest or its app-local URL. String values
+     * are loaded by this SDK and posted inline; Connect never fetches them.
+     */
+    manifest?: MdbaseAppManifest | string | URL;
+    redirectUri?: string | URL;
+    storage?: Storage;
+    /** Encrypted relay is required by default for newly authorized grants. */
+    relayEncryption?: "required" | "disabled";
+    keyStore?: GrantKeyStore;
+    /** Persistent installation signing identity; separate from disposable grant keys. */
+    identityStore?: ApplicationIdentityStore;
+    /** Prefer same-computer connector access when the browser permits it. */
+    directAccess?: "auto" | "disabled";
+    /** Loopback origin override for development and automated testing. */
+    loopbackUrl?: string | URL;
+    /** Override browser navigation, for example to use a native system browser. */
+    navigate?: (url: string) => void | Promise<void>;
+    /** Workload-specific defaults. Per-call timeoutMs always wins. */
+    timeouts?: MdbaseConnectTimeouts;
+}
+export type MdbaseFrontmatter = JsonObject;

package/dist/connect-options.js

@@ -0,0 +1 @@
+export {};

package/dist/connect.d.ts

@@ -0,0 +1,66 @@
+import type { JsonObject } from "@mdbase-dev/connect-protocol";
+import { type MdbaseApplicationManifest as MdbaseAppManifest } from "./application-contract.js";
+import { type ApplicationIdentityStore } from "./application-identity.js";
+import { MdbaseConnection, type MdbaseAuthorizationOutcome, type MdbaseAuthorizationResult, type MdbaseAuthorizeOptions, type MdbaseConnectEnvironment } from "./connection.js";
+import type { MdbaseConnectOptions } from "./connect-options.js";
+import type { MdbaseConnectionInfo } from "./connection-types.js";
+import { type GrantKeyStore } from "./crypto.js";
+import { type Application, type StoredToken } from "./internal-types.js";
+import type { ConnectRequestOptions } from "./operation-types.js";
+import { type ResolvedConnectTimeouts } from "./request-budget.js";
+import type { MdbaseUnavailableReason } from "./session.js";
+export declare class MdbaseConnectInternals<Frontmatter extends JsonObject> {
+    readonly serverUrl: string;
+    readonly manifest: MdbaseAppManifest | string;
+    readonly manifestSource: string;
+    readonly redirectUri: string;
+    readonly storage: Storage;
+    readonly relayEncryption: "required" | "disabled";
+    readonly keyStore: GrantKeyStore;
+    readonly identityStore: ApplicationIdentityStore;
+    readonly directAccessMode: "auto" | "disabled";
+    readonly loopbackUrl: string;
+    readonly navigate?: (url: string) => void | Promise<void>;
+    readonly timeouts: ResolvedConnectTimeouts;
+    readonly credentialStorage: MdbaseConnectEnvironment["credentialStorage"];
+    private application;
+    private manifestPromise;
+    private readonly completionPromises;
+    private readonly grantKeyLeases;
+    private readonly connectionCache;
+    private readonly listeners;
+    private readonly invalidatedConnections;
+    constructor(options: MdbaseConnectOptions);
+    environment(): MdbaseConnectEnvironment;
+    register(options?: ConnectRequestOptions): Promise<Application>;
+    private registerWithinBudget;
+    manifestDeclaration(options?: ConnectRequestOptions): Promise<MdbaseAppManifest>;
+    private loadManifest;
+    authorize(options?: MdbaseAuthorizeOptions): Promise<MdbaseAuthorizationOutcome<Frontmatter>>;
+    private authorizeWithinBudget;
+    private authorizeWeb;
+    private authorizePortable;
+    completeAuthorization(callbackUrl: string, options?: ConnectRequestOptions): Promise<MdbaseAuthorizationResult<Frontmatter>>;
+    private performAuthorizationCompletion;
+    connections(): MdbaseConnectionInfo[];
+    connection(collectionId: string): MdbaseConnection<Frontmatter> | null;
+    unavailableReason(collectionId: string): MdbaseUnavailableReason | null;
+    connectionApplicationId(collectionId: string): string | null;
+    onConnectionsChange(listener: (connections: MdbaseConnectionInfo[]) => void): () => void;
+    storeTokenResponse(body: any, clientId: string, keyHandle?: string): StoredToken;
+    forgetConnectorIdentity(connectorId: string): void;
+    private pinConnectorIdentity;
+    private connectorPinKey;
+    private loadApplicationIdentity;
+    removeToken(collectionId: string, keyHandle?: string, reason?: MdbaseUnavailableReason, discardPending?: boolean): void;
+    acquireGrantKeyLease(collectionId: string, keyHandle: string, signal?: AbortSignal): Promise<() => void>;
+    deleteGrantKeyWhenUnused(collectionId: string, keyHandle: string): void;
+    tokenKey(collectionId: string): string;
+    pendingMutationKey(collectionId: string): string;
+    notificationKey(collectionId: string, transport?: "web_push" | "fcm"): string;
+    directPreferenceKey(): string;
+    defaultApplicationOrigin(): string;
+    private pendingKey;
+    private storagePrefix;
+    private emitConnections;
+}