@mdbase-dev/connect 0.1.0-beta.21

package/dist/session.js

@@ -0,0 +1,271 @@
+import { authorizationReturnToFromError, isAuthorizationCallbackUrl } from "./authorization-url.js";
+import { MdbaseConnectError } from "./errors.js";
+import { DEFAULT_OPERATIONS } from "./internal-types.js";
+import { uniqueOperations } from "./operation-helpers.js";
+export class MdbaseSession {
+    connect;
+    operations;
+    selection;
+    autoSelect;
+    listeners = new Set();
+    snapshot;
+    snapshotKey = "";
+    stopConnections;
+    stopSelection;
+    stopActiveConnection;
+    activeCollectionId = null;
+    unavailableReason = "not_authorized";
+    started = false;
+    refreshing = false;
+    refreshQueued = false;
+    transactionDepth = 0;
+    callbackPromise = null;
+    constructor(connect, options) {
+        this.connect = connect;
+        this.operations = uniqueOperations(options.operations ?? DEFAULT_OPERATIONS);
+        this.selection = options.selection;
+        this.autoSelect = options.autoSelect ?? "only";
+        this.snapshot = { status: "unselected", connections: [] };
+        this.refresh();
+    }
+    async start() {
+        if (!this.started) {
+            this.started = true;
+            this.stopConnections = this.connect.onConnectionsChange(() => this.refresh());
+            this.stopSelection = this.selection.subscribe(() => {
+                this.unavailableReason = "not_authorized";
+                this.refresh();
+            });
+        }
+        const callback = this.selection.authorizationCallback();
+        if (callback)
+            await this.handleAuthorizationCallback(callback);
+        else
+            this.autoSelectOnlyConnection();
+        this.refresh();
+        return this.snapshot;
+    }
+    destroy() {
+        this.stopConnections?.();
+        this.stopSelection?.();
+        this.stopActiveConnection?.();
+        this.stopConnections = undefined;
+        this.stopSelection = undefined;
+        this.stopActiveConnection = undefined;
+        this.activeCollectionId = null;
+        this.started = false;
+    }
+    getSnapshot() {
+        return this.snapshot;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    select(collectionId, options = {}) {
+        const connection = this.connect.connection(collectionId);
+        if (!connection) {
+            throw new MdbaseConnectError("unknown_collection", "This collection is not authorized for this application.");
+        }
+        this.unavailableReason = "not_authorized";
+        this.selection.select(collectionId, options);
+        this.refresh();
+        return connection;
+    }
+    clearSelection(options = {}) {
+        this.unavailableReason = "not_authorized";
+        this.selection.select(null, options);
+        this.refresh();
+    }
+    forget(collectionId) {
+        this.transactionDepth += 1;
+        try {
+            const selected = this.selection.selectedCollectionId() === collectionId;
+            this.connect.connection(collectionId)?.forget();
+            if (selected)
+                this.selection.select(null, { history: "replace" });
+        }
+        finally {
+            this.transactionDepth -= 1;
+            this.refresh();
+        }
+    }
+    async authorize(target, options = {}) {
+        const selectedCollectionId = this.selection.selectedCollectionId();
+        if (target === "selected" && !selectedCollectionId) {
+            throw new MdbaseConnectError("collection_not_selected", "Choose a collection before updating its access.");
+        }
+        const targetCollectionId = typeof target === "object"
+            ? target.collectionId
+            : target === "selected"
+                ? selectedCollectionId
+                : null;
+        this.transactionDepth += 1;
+        try {
+            const outcome = await this.connect.authorize({
+                ...options,
+                operations: this.operations,
+                target: targetCollectionId === null
+                    ? { kind: "choose" }
+                    : { kind: "collection", collectionId: targetCollectionId },
+                returnTo: this.selection.authorizationReturnTo()
+            });
+            if (outcome.kind === "connected") {
+                this.selection.finishAuthorization(outcome.returnTo, outcome.connection.collectionId);
+            }
+            return outcome;
+        }
+        finally {
+            this.transactionDepth -= 1;
+            this.refresh();
+        }
+    }
+    async ensureOperations(requiredOperations) {
+        const current = this.snapshot;
+        if (current.status !== "ready") {
+            throw new MdbaseConnectError("collection_not_ready", "Choose an authorized collection first.");
+        }
+        const required = uniqueOperations(requiredOperations);
+        const capabilities = current.connection.authorizationCapabilities(required);
+        if (capabilities.sufficient)
+            return { kind: "unchanged", connection: current.connection };
+        this.transactionDepth += 1;
+        try {
+            const outcome = await this.connect.authorize({
+                operations: uniqueOperations([...capabilities.grantedOperations, ...capabilities.missingOperations]),
+                target: { kind: "collection", collectionId: current.collectionId },
+                returnTo: this.selection.authorizationReturnTo()
+            });
+            if (outcome.kind === "connected") {
+                this.selection.finishAuthorization(outcome.returnTo, outcome.connection.collectionId);
+            }
+            return outcome;
+        }
+        finally {
+            this.transactionDepth -= 1;
+            this.refresh();
+        }
+    }
+    handleAuthorizationCallback(callbackUrl) {
+        if (!isAuthorizationCallbackUrl(callbackUrl)) {
+            return Promise.reject(new MdbaseConnectError("invalid_callback", "This URL is not an authorization callback."));
+        }
+        if (this.callbackPromise)
+            return this.callbackPromise;
+        this.transactionDepth += 1;
+        const completion = this.connect.completeAuthorization(callbackUrl)
+            .then((result) => {
+            this.unavailableReason = "not_authorized";
+            this.selection.finishAuthorization(result.returnTo, result.connection.collectionId);
+            this.refresh();
+            return result.connection;
+        })
+            .catch((error) => {
+            const returnTo = authorizationReturnToFromError(error);
+            this.selection.clearAuthorizationCallback(returnTo);
+            this.refresh();
+            throw error;
+        })
+            .finally(() => {
+            this.transactionDepth -= 1;
+            this.refresh();
+            if (this.callbackPromise === completion)
+                this.callbackPromise = null;
+        });
+        this.callbackPromise = completion;
+        return completion;
+    }
+    autoSelectOnlyConnection() {
+        if (this.autoSelect !== "only" || this.selection.selectedCollectionId())
+            return;
+        const connections = this.connect.connections();
+        if (connections.length === 1) {
+            this.selection.select(connections[0].collectionId, { history: "replace" });
+        }
+    }
+    refresh() {
+        if (this.transactionDepth > 0) {
+            this.refreshQueued = true;
+            return;
+        }
+        if (this.refreshing) {
+            this.refreshQueued = true;
+            return;
+        }
+        this.refreshing = true;
+        try {
+            do {
+                this.refreshQueued = false;
+                this.refreshOnce();
+            } while (this.refreshQueued);
+        }
+        finally {
+            this.refreshing = false;
+        }
+    }
+    refreshOnce() {
+        const collectionId = this.selection.selectedCollectionId();
+        const connections = this.connect.connections();
+        const connection = collectionId ? this.connect.connection(collectionId) : null;
+        if (connection?.collectionId !== this.activeCollectionId) {
+            this.stopActiveConnection?.();
+            this.activeCollectionId = connection?.collectionId ?? null;
+            this.stopActiveConnection = connection?.onConnectionChange((info) => {
+                if (!info && this.selection.selectedCollectionId() === connection.collectionId) {
+                    this.unavailableReason = "authorization_lost";
+                }
+                this.refresh();
+            });
+        }
+        let next;
+        if (!collectionId) {
+            next = { status: "unselected", connections };
+        }
+        else if (!connection || !connection.info()) {
+            next = {
+                status: "unavailable",
+                collectionId,
+                reason: this.connect.unavailableReason(collectionId) ?? this.unavailableReason,
+                connections
+            };
+        }
+        else {
+            const info = connection.info();
+            next = {
+                status: "ready",
+                collectionId,
+                connection,
+                info,
+                access: connection.authorizationCapabilities(this.operations),
+                connections
+            };
+        }
+        const key = sessionSnapshotKey(next);
+        if (key === this.snapshotKey)
+            return;
+        this.snapshot = next;
+        this.snapshotKey = key;
+        for (const listener of this.listeners)
+            listener();
+    }
+}
+function sessionSnapshotKey(snapshot) {
+    if (snapshot.status === "unselected") {
+        return JSON.stringify({ status: snapshot.status, connections: snapshot.connections });
+    }
+    if (snapshot.status === "unavailable") {
+        return JSON.stringify({
+            status: snapshot.status,
+            collectionId: snapshot.collectionId,
+            reason: snapshot.reason,
+            connections: snapshot.connections
+        });
+    }
+    return JSON.stringify({
+        status: snapshot.status,
+        collectionId: snapshot.collectionId,
+        info: snapshot.info,
+        access: snapshot.access,
+        connections: snapshot.connections
+    });
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@mdbase-dev/connect",
+  "version": "0.1.0-beta.21",
+  "private": false,
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mdbase-dev/mdbase-connect.git",
+    "directory": "packages/client"
+  },
+  "homepage": "https://mdbase.dev/sdk/",
+  "sideEffects": false,
+  "browser": "./dist/browser/mdbase-connect.min.js",
+  "unpkg": "./dist/browser/mdbase-connect.min.js",
+  "jsdelivr": "./dist/browser/mdbase-connect.min.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@mdbase-dev/connect-protocol": "0.1.0-beta.21"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && node scripts/build-browser.mjs",
+    "test": "vitest run",
+    "test:browser-storage": "pnpm build && node scripts/browser-storage.test.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}