@oxyhq/core 7.0.0 → 7.1.1

package/dist/cjs/session/accountProjection.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Unified account-list projection — THE single source of truth.
+ *
+ * Produces the flat `SwitchableAccount[]` every account chooser renders, by
+ * merging the device's server-authoritative session set (`DeviceSessionState`
+ * from {@link SessionClient}) with the caller's account graph (`AccountNode[]`
+ * from `oxyServices.listAccounts()`), deduped by `accountId`. This lives in
+ * `@oxyhq/core` so `@oxyhq/services` (RN) and `@oxyhq/auth` (web) — and
+ * `auth.oxy.so` — all render the SAME list from the SAME logic and cannot
+ * diverge.
+ *
+ * Pure and I/O-free: the caller resolves per-account profiles via
+ * `oxyServices.getUsersByIds(...)` and passes them in as `profilesById`, and
+ * binds `resolveAvatarUrl` to `oxyServices.getFileDownloadUrl`. This is the same
+ * split the former `@oxyhq/services` `buildSwitchableAccounts` used — hoisted
+ * into core, keyed directly on `DeviceSessionState` (whose `activeAccountId` is
+ * atomic, so no cross-call current-row reconciliation is needed).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectSwitchableAccounts = projectSwitchableAccounts;
+exports.switchableAccountIds = switchableAccountIds;
+const accountUtils_1 = require("../utils/accountUtils");
+/**
+ * Pure union of device sign-ins and account-graph nodes into the flat
+ * {@link SwitchableAccount}[] every switcher renders.
+ *
+ * Order: device rows first (in `state.accounts` order, active flagged), then
+ * graph-only rows (in graph order). An account present as BOTH a device session
+ * and a graph node is deduped into ONE device row enriched with the graph
+ * metadata (relationship / kind / parent / membership).
+ */
+function projectSwitchableAccounts(input) {
+    const { state, graph, profilesById, activeUser, locale, resolveAvatarUrl } = input;
+    const activeAccountId = state?.activeAccountId ?? null;
+    const toRow = (accountUser, opts) => {
+        const accountId = accountUser.id?.toString() ?? '';
+        const handle = (0, accountUtils_1.getAccountFallbackHandle)(accountUser);
+        const secondaryHandle = handle ? `@${handle}` : null;
+        return {
+            accountId,
+            sessionId: opts.sessionId,
+            authuser: opts.authuser,
+            isCurrent: Boolean(accountId) && accountId === activeAccountId,
+            onDevice: Boolean(opts.sessionId),
+            relationship: opts.relationship,
+            kind: opts.kind,
+            parentAccountId: opts.parentAccountId,
+            callerMembership: opts.callerMembership,
+            displayName: (0, accountUtils_1.getAccountDisplayName)(accountUser, locale),
+            // Real email, or the `@handle` fallback (NEVER synthesized).
+            email: accountUser.email ?? secondaryHandle,
+            avatarUrl: resolveAvatarUrl(accountUser.avatar),
+            color: accountUser.color ?? null,
+            user: accountUser,
+        };
+    };
+    // --- Device rows (from the server-authoritative session set) ---
+    const deviceRows = (state?.accounts ?? []).flatMap((account) => {
+        const isActive = account.accountId === activeAccountId;
+        // The active row prefers the freshest `activeUser` (when supplied), then the
+        // batch-resolved profile; every other row uses the batch-resolved profile.
+        const accountUser = isActive && activeUser
+            ? activeUser
+            : profilesById.get(account.accountId);
+        if (!accountUser) {
+            return [];
+        }
+        return [toRow(accountUser, { sessionId: account.sessionId, authuser: account.authuser })];
+    });
+    // --- Merge graph nodes, deduping by account id ---
+    const byAccountId = new Map();
+    const order = [];
+    const remember = (row) => {
+        if (!row.accountId || byAccountId.has(row.accountId)) {
+            return;
+        }
+        byAccountId.set(row.accountId, row);
+        order.push(row.accountId);
+    };
+    for (const row of deviceRows) {
+        remember(row);
+    }
+    for (const node of graph) {
+        const existing = byAccountId.get(node.accountId);
+        if (existing) {
+            // On-device account that is ALSO in the graph: enrich the device row with
+            // graph metadata; keep its (freshest) profile + sessionId + active flag.
+            byAccountId.set(node.accountId, {
+                ...existing,
+                relationship: node.relationship,
+                kind: node.kind,
+                parentAccountId: node.parentAccountId,
+                callerMembership: node.callerMembership,
+            });
+            continue;
+        }
+        // Graph-only account (owned org / shared, not yet a device session).
+        remember(toRow(node.account, {
+            relationship: node.relationship,
+            kind: node.kind,
+            parentAccountId: node.parentAccountId,
+            callerMembership: node.callerMembership,
+        }));
+    }
+    return order.flatMap((id) => {
+        const row = byAccountId.get(id);
+        return row ? [row] : [];
+    });
+}
+/**
+ * Every distinct account id referenced by a device session set AND an account
+ * graph, sorted for a stable profile-fetch key. Feed to
+ * `oxyServices.getUsersByIds(...)`; graph nodes already embed their `account`
+ * document, but including their ids lets the caller pass one id set and lets the
+ * projection prefer freshly-fetched profiles uniformly.
+ */
+function switchableAccountIds(state, graph) {
+    const ids = new Set();
+    for (const account of state?.accounts ?? []) {
+        if (account.accountId) {
+            ids.add(account.accountId);
+        }
+    }
+    for (const node of graph) {
+        if (node.accountId) {
+            ids.add(node.accountId);
+        }
+    }
+    return Array.from(ids).sort();
+}

package/dist/cjs/session/createSessionClient.js

@@ -25,8 +25,15 @@ const sessionClientHost_1 = require("./sessionClientHost");
  * specifier (bundler-fragile in Metro/Expo-web and Vite against the published
  * dist). When omitted, the client falls back to the lazy loader.
  */
-function createSessionClient(oxyServices, transport, socketFactory) {
+function createSessionClient(oxyServices, transport, socketFactory, 
+/**
+ * Optional signed-out realtime wiring: `signedOutSocketAuth` (open the socket
+ * while signed out so an idle tab receives its device pushes) and
+ * `onSessionAppeared` (self-acquire when a sibling signs in). See
+ * {@link SessionClientOptions}.
+ */
+extra) {
     const host = (0, sessionClientHost_1.createSessionClientHost)(oxyServices);
-    const client = new SessionClient_1.SessionClient(host, { transport, socketFactory });
+    const client = new SessionClient_1.SessionClient(host, { transport, socketFactory, ...extra });
     return { client, host };
 }