gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/cloud/team/collections-sync.ts

@@ -0,0 +1,222 @@
+import { useEffect, useRef, useSyncExternalStore } from "react";
+import {
+  apiClient,
+  type TeamCollection,
+  type TeamCollectionEvent,
+  type TeamCollectionItem,
+} from "../../../../api-client";
+import type { AppTickerRepositoryPort } from "../../../../core/app-service-ports";
+import type { AppAction, AppState } from "../../../../core/state/app/types";
+import { useAppDispatch, useAppSelector, useAppStateRef } from "../../../../state/app/context";
+import type { TickerRecord } from "../../../../types/ticker";
+import {
+  applyMembership,
+  blankTickerRecord,
+  diffMembership,
+  localMembership,
+  parseCollectionRef,
+  reconcileConfigCollections,
+  teamCollectionLocalId,
+} from "./collections";
+import { teamStore } from "./store";
+
+export interface TeamCollectionsHost {
+  dispatch: (action: AppAction) => void;
+  getState: () => AppState;
+  persistConfig: (config: AppState["config"]) => void;
+  tickerRepository: AppTickerRepositoryPort;
+}
+
+type KnownItems = Map<string, Map<string, TeamCollectionItem>>;
+
+const OUTBOUND_DEBOUNCE_MS = 400;
+
+/**
+ * Keeps team watchlists and paper portfolios in step with the server at the
+ * item level. Inbound: the collection list and every item on start, then each
+ * collection.updated frame. Outbound: any local membership change on a team
+ * collection is pushed as an add, update, or remove. There are no revisions,
+ * so the last known server set is what local edits are diffed against.
+ */
+export function useTeamCollectionsSync(host: Omit<TeamCollectionsHost, "dispatch" | "getState">): void {
+  const dispatch = useAppDispatch();
+  const stateRef = useAppStateRef();
+  const tickers = useAppSelector((state) => state.tickers);
+  const teams = useSyncExternalStore(
+    (onChange) => teamStore.subscribe(onChange),
+    () => teamStore.getSnapshot().teams,
+  );
+  const known = useRef<KnownItems>(new Map());
+  const collectionsRef = useRef<Map<string, TeamCollection>>(new Map());
+  const applying = useRef(false);
+  const outboundTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const saveTicker = async (ticker: TickerRecord) => {
+    await host.tickerRepository.saveTicker(ticker);
+    dispatch({ type: "UPDATE_TICKER", ticker });
+  };
+
+  const applyItem = async (collection: TeamCollection, symbol: string, exchange: string, item: TeamCollectionItem | null) => {
+    const localId = teamCollectionLocalId(collection.teamId, collection.id);
+    const current = stateRef.current.tickers;
+    let ticker = current.get(symbol) ?? (await host.tickerRepository.loadTicker(symbol));
+    if (!ticker) {
+      if (!item) return;
+      ticker = await host.tickerRepository.createTicker(blankTickerRecord(symbol, exchange, collection.currency ?? "USD").metadata);
+    }
+    const next = applyMembership(ticker, localId, collection.kind, item, collection.currency ?? "USD");
+    if (next) await saveTicker(next);
+  };
+
+  const applyCollections = async (teamIds: string[], collections: TeamCollection[]) => {
+    applying.current = true;
+    try {
+      const state = stateRef.current;
+      const nextConfig = reconcileConfigCollections(state.config, teamIds, collections);
+      if (nextConfig !== state.config) {
+        dispatch({ type: "SET_CONFIG", config: nextConfig });
+        host.persistConfig(nextConfig);
+      }
+      // Collections that disappeared upstream release their local members.
+      for (const [localId, previous] of collectionsRef.current) {
+        if (collections.some((entry) => teamCollectionLocalId(entry.teamId, entry.id) === localId)) continue;
+        if (!teamIds.includes(previous.teamId)) continue;
+        for (const [symbol] of localMembership(stateRef.current.tickers, localId, previous.kind)) {
+          await applyItem(previous, symbol, "", null);
+        }
+        collectionsRef.current.delete(localId);
+        known.current.delete(localId);
+      }
+      for (const collection of collections) {
+        const localId = teamCollectionLocalId(collection.teamId, collection.id);
+        collectionsRef.current.set(localId, collection);
+        const detail = await apiClient.getTeamCollection(collection.teamId, collection.id).catch(() => null);
+        if (!detail) continue;
+        const items = new Map(detail.items.map((item) => [item.symbol, item]));
+        known.current.set(localId, items);
+        for (const item of detail.items) await applyItem(collection, item.symbol, item.exchange, item);
+        for (const [symbol] of localMembership(stateRef.current.tickers, localId, collection.kind)) {
+          if (!items.has(symbol)) await applyItem(collection, symbol, "", null);
+        }
+      }
+    } finally {
+      applying.current = false;
+    }
+  };
+
+  const refresh = async () => {
+    if (!apiClient.isVerified()) return;
+    const currentTeams = teamStore.getSnapshot().teams;
+    const teamIds = currentTeams.map((team) => team.id);
+    const lists = await Promise.all(currentTeams.map((team) => apiClient.listTeamCollections(team.id).catch(() => [] as TeamCollection[])));
+    await applyCollections(teamIds, lists.flat());
+  };
+
+  const applyEvent = async (event: TeamCollectionEvent) => {
+    if (event.change === "created" || event.change === "updated") {
+      collectionsRef.current.set(teamCollectionLocalId(event.teamId, event.collection.id), event.collection);
+      const all = [...collectionsRef.current.values()].filter((entry) => entry.teamId === event.teamId);
+      applying.current = true;
+      try {
+        const state = stateRef.current;
+        const nextConfig = reconcileConfigCollections(state.config, [event.teamId], all);
+        if (nextConfig !== state.config) {
+          dispatch({ type: "SET_CONFIG", config: nextConfig });
+          host.persistConfig(nextConfig);
+        }
+      } finally {
+        applying.current = false;
+      }
+      if (event.change === "created") known.current.set(teamCollectionLocalId(event.teamId, event.collection.id), new Map());
+      return;
+    }
+    if (event.change === "deleted") {
+      const localId = teamCollectionLocalId(event.teamId, event.collectionId);
+      const previous = collectionsRef.current.get(localId);
+      if (!previous) return;
+      const remaining = [...collectionsRef.current.values()].filter((entry) => entry.teamId === event.teamId && entry.id !== event.collectionId);
+      await applyCollections([event.teamId], remaining);
+      return;
+    }
+    const localId = teamCollectionLocalId(event.teamId, event.collectionId);
+    const collection = collectionsRef.current.get(localId);
+    if (!collection) return;
+    const items = known.current.get(localId) ?? new Map<string, TeamCollectionItem>();
+    known.current.set(localId, items);
+    applying.current = true;
+    try {
+      if (event.change === "item-removed") {
+        items.delete(event.item.symbol);
+        await applyItem(collection, event.item.symbol, event.item.exchange, null);
+      } else {
+        items.set(event.item.symbol, event.item);
+        await applyItem(collection, event.item.symbol, event.item.exchange, event.item);
+      }
+    } finally {
+      applying.current = false;
+    }
+  };
+
+  const pushOutbound = async () => {
+    if (applying.current || !apiClient.isVerified()) return;
+    for (const [localId, collection] of collectionsRef.current) {
+      const ref = parseCollectionRef(localId);
+      if (ref.scope !== "team") continue;
+      const items = known.current.get(localId);
+      if (!items) continue;
+      const local = localMembership(stateRef.current.tickers, localId, collection.kind);
+      const diff = diffMembership(local, items);
+      for (const entry of diff.add) {
+        const ticker = local.get(entry.symbol)?.ticker;
+        try {
+          const item = await apiClient.putTeamCollectionItem(collection.teamId, collection.id, {
+            symbol: entry.symbol,
+            exchange: ticker?.metadata.exchange ?? null,
+            ...(collection.kind === "portfolio" ? { quantity: entry.quantity } : {}),
+          });
+          items.set(item.symbol, item);
+        } catch (error) {
+          console.error("[teams] Could not add to a team collection:", error);
+        }
+      }
+      for (const symbol of diff.remove) {
+        const item = items.get(symbol);
+        try {
+          await apiClient.removeTeamCollectionItem(collection.teamId, collection.id, symbol, item?.exchange ?? "");
+          items.delete(symbol);
+        } catch (error) {
+          console.error("[teams] Could not remove from a team collection:", error);
+        }
+      }
+    }
+  };
+
+  const teamKey = teams.map((team) => team.id).join(",");
+  useEffect(() => {
+    void refresh();
+    const unsubscribeUser = apiClient.subscribeCurrentUser(() => {
+      void refresh();
+    });
+    const unsubscribeEvents = apiClient.subscribeCloudEvent("collection.updated", (data) => {
+      void applyEvent(data as TeamCollectionEvent);
+    });
+    return () => {
+      unsubscribeUser();
+      unsubscribeEvents();
+    };
+    // Team membership drives which collections to follow.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [teamKey]);
+
+  useEffect(() => {
+    if (outboundTimer.current) clearTimeout(outboundTimer.current);
+    outboundTimer.current = setTimeout(() => {
+      outboundTimer.current = null;
+      void pushOutbound();
+    }, OUTBOUND_DEBOUNCE_MS);
+    return () => {
+      if (outboundTimer.current) clearTimeout(outboundTimer.current);
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [tickers]);
+}

package/src/plugins/builtin/cloud/team/collections.test.ts

@@ -0,0 +1,126 @@
+import { describe, expect, test } from "bun:test";
+import type { TeamCollection, TeamCollectionItem } from "../../../../api-client";
+import { createDefaultConfig } from "../../../../types/config";
+import type { TickerRecord } from "../../../../types/ticker";
+import {
+  applyMembership,
+  blankTickerRecord,
+  diffMembership,
+  localMembership,
+  parseCollectionRef,
+  reconcileConfigCollections,
+  teamCollectionLocalId,
+} from "./collections";
+
+function collection(overrides: Partial<TeamCollection>): TeamCollection {
+  return {
+    id: "c1",
+    teamId: "org-1",
+    kind: "watchlist",
+    name: "Rates names",
+    currency: null,
+    createdBy: "u1",
+    createdAt: "2026-09-14T12:00:00.000Z",
+    updatedAt: "2026-09-14T12:00:00.000Z",
+    itemCount: 0,
+    ...overrides,
+  };
+}
+
+function item(symbol: string, quantity: number | null = null): TeamCollectionItem {
+  return {
+    collectionId: "c1",
+    symbol,
+    exchange: "",
+    quantity,
+    note: null,
+    addedBy: "u1",
+    addedAt: "2026-09-14T12:00:00.000Z",
+    updatedAt: "2026-09-14T12:00:00.000Z",
+  };
+}
+
+describe("scoped collection references", () => {
+  test("bare ids are personal, team ids carry the team", () => {
+    expect(parseCollectionRef("main")).toEqual({ scope: "user", id: "main" });
+    expect(parseCollectionRef(teamCollectionLocalId("org-1", "c1"))).toEqual({ scope: "team", teamId: "org-1", id: "c1" });
+    expect(parseCollectionRef("team:broken")).toEqual({ scope: "user", id: "team:broken" });
+    expect(parseCollectionRef("team:org-1:")).toEqual({ scope: "user", id: "team:org-1:" });
+  });
+});
+
+describe("reconcileConfigCollections", () => {
+  test("replaces a team's entries and leaves personal and other teams alone", () => {
+    const config = {
+      ...createDefaultConfig("/tmp/gloomberb-team-collections"),
+      watchlists: [
+        { id: "mine", name: "Mine" },
+        { id: teamCollectionLocalId("org-2", "x"), name: "Other team", teamId: "org-2" },
+        { id: teamCollectionLocalId("org-1", "stale"), name: "Stale", teamId: "org-1" },
+      ],
+      portfolios: [{ id: "main", name: "Main", currency: "USD" }],
+    };
+    const next = reconcileConfigCollections(config, ["org-1"], [
+      collection({ id: "c1", name: "Rates names" }),
+      collection({ id: "c2", kind: "portfolio", name: "Paper book", currency: "EUR" }),
+    ]);
+    expect(next.watchlists).toEqual([
+      { id: "mine", name: "Mine" },
+      { id: "team:org-2:x", name: "Other team", teamId: "org-2" },
+      { id: "team:org-1:c1", name: "Rates names", teamId: "org-1" },
+    ]);
+    expect(next.portfolios).toEqual([
+      { id: "main", name: "Main", currency: "USD" },
+      { id: "team:org-1:c2", name: "Paper book", currency: "EUR", teamId: "org-1" },
+    ]);
+    expect(reconcileConfigCollections(next, ["org-1"], [
+      collection({ id: "c1", name: "Rates names" }),
+      collection({ id: "c2", kind: "portfolio", name: "Paper book", currency: "EUR" }),
+    ])).toBe(next);
+  });
+});
+
+describe("membership", () => {
+  const localId = teamCollectionLocalId("org-1", "c1");
+  const aapl: TickerRecord = blankTickerRecord("AAPL", "NASDAQ", "USD");
+
+  test("applies watchlist adds and removes only when something changes", () => {
+    const added = applyMembership(aapl, localId, "watchlist", item("AAPL"), "USD");
+    expect(added?.metadata.watchlists).toEqual([localId]);
+    expect(applyMembership(added!, localId, "watchlist", item("AAPL"), "USD")).toBeNull();
+    const removed = applyMembership(added!, localId, "watchlist", null, "USD");
+    expect(removed?.metadata.watchlists).toEqual([]);
+    expect(applyMembership(aapl, localId, "watchlist", null, "USD")).toBeNull();
+  });
+
+  test("paper portfolio items carry a manual position with the quantity", () => {
+    const added = applyMembership(aapl, localId, "portfolio", item("AAPL", 10), "EUR");
+    expect(added?.metadata.portfolios).toEqual([localId]);
+    expect(added?.metadata.positions).toEqual([
+      { portfolio: localId, shares: 10, avgCost: 0, currency: "EUR", broker: "manual" },
+    ]);
+    const updated = applyMembership(added!, localId, "portfolio", item("AAPL", 12), "EUR");
+    expect(updated?.metadata.positions[0]?.shares).toBe(12);
+    expect(applyMembership(updated!, localId, "portfolio", item("AAPL", 12), "EUR")).toBeNull();
+    const cleared = applyMembership(updated!, localId, "portfolio", null, "EUR");
+    expect(cleared?.metadata.portfolios).toEqual([]);
+    expect(cleared?.metadata.positions).toEqual([]);
+  });
+
+  test("reads local membership and diffs it against the known server set", () => {
+    const inList = applyMembership(aapl, localId, "portfolio", item("AAPL", 10), "USD")!;
+    const msft = applyMembership(blankTickerRecord("MSFT", "", "USD"), localId, "portfolio", item("MSFT", 3), "USD")!;
+    const tickers = new Map<string, TickerRecord>([["AAPL", inList], ["MSFT", msft], ["TSLA", blankTickerRecord("TSLA", "", "USD")]]);
+    const local = localMembership(tickers, localId, "portfolio");
+    expect([...local.keys()]).toEqual(["AAPL", "MSFT"]);
+    expect(local.get("AAPL")?.quantity).toBe(10);
+
+    const known = new Map([["AAPL", item("AAPL", 10)], ["NVDA", item("NVDA", 1)]]);
+    expect(diffMembership(local, known)).toEqual({
+      add: [{ symbol: "MSFT", quantity: 3 }],
+      remove: ["NVDA"],
+    });
+    const knownStale = new Map([["AAPL", item("AAPL", 8)]]);
+    expect(diffMembership(local, knownStale).add.map((entry) => entry.symbol)).toEqual(["AAPL", "MSFT"]);
+  });
+});

package/src/plugins/builtin/cloud/team/collections.ts

@@ -0,0 +1,181 @@
+import type { TeamCollection, TeamCollectionItem } from "../../../../api-client";
+import type { AppConfig } from "../../../../types/config";
+import type { Portfolio, TickerRecord, Watchlist } from "../../../../types/ticker";
+
+const TEAM_COLLECTION_PREFIX = "team:";
+
+/** A scoped reference: bare ids are personal, `team:<teamId>:<id>` is shared. */
+export interface ScopedCollectionRef {
+  scope: "user" | "team";
+  teamId?: string;
+  id: string;
+}
+
+export function teamCollectionLocalId(teamId: string, collectionId: string): string {
+  return `${TEAM_COLLECTION_PREFIX}${teamId}:${collectionId}`;
+}
+
+export function parseCollectionRef(localId: string): ScopedCollectionRef {
+  if (!localId.startsWith(TEAM_COLLECTION_PREFIX)) return { scope: "user", id: localId };
+  const rest = localId.slice(TEAM_COLLECTION_PREFIX.length);
+  const separator = rest.indexOf(":");
+  if (separator <= 0 || separator === rest.length - 1) return { scope: "user", id: localId };
+  return { scope: "team", teamId: rest.slice(0, separator), id: rest.slice(separator + 1) };
+}
+
+export function isTeamCollectionId(localId: string): boolean {
+  return parseCollectionRef(localId).scope === "team";
+}
+
+/** The config entries a team's server collections map onto. */
+export function collectionsToConfigEntries(
+  collections: readonly TeamCollection[],
+): { watchlists: Watchlist[]; portfolios: Portfolio[] } {
+  const watchlists: Watchlist[] = [];
+  const portfolios: Portfolio[] = [];
+  for (const collection of collections) {
+    const id = teamCollectionLocalId(collection.teamId, collection.id);
+    if (collection.kind === "watchlist") watchlists.push({ id, name: collection.name, teamId: collection.teamId });
+    else portfolios.push({ id, name: collection.name, currency: collection.currency ?? "USD", teamId: collection.teamId });
+  }
+  return { watchlists, portfolios };
+}
+
+/**
+ * Replaces the team-owned entries in the config with what the server holds,
+ * for the given teams only, leaving personal and other teams' entries alone.
+ * Returns the same config object when nothing changed.
+ */
+export function reconcileConfigCollections(
+  config: AppConfig,
+  teamIds: readonly string[],
+  collections: readonly TeamCollection[],
+): AppConfig {
+  const teams = new Set(teamIds);
+  const owned = (entry: { teamId?: string }) => !!entry.teamId && teams.has(entry.teamId);
+  const next = collectionsToConfigEntries(collections.filter((entry) => teams.has(entry.teamId)));
+  const keepWatchlists = config.watchlists.filter((entry) => !owned(entry));
+  const keepPortfolios = config.portfolios.filter((entry) => !owned(entry));
+  const watchlists = [...keepWatchlists, ...next.watchlists];
+  const portfolios = [...keepPortfolios, ...next.portfolios];
+  const same = (a: readonly { id: string; name: string; currency?: string }[], b: readonly { id: string; name: string; currency?: string }[]) =>
+    a.length === b.length && a.every((entry, index) => entry.id === b[index]?.id && entry.name === b[index]?.name && entry.currency === b[index]?.currency);
+  if (same(config.watchlists, watchlists) && same(config.portfolios, portfolios)) return config;
+  return { ...config, watchlists, portfolios };
+}
+
+/** Which tickers a team collection holds locally, keyed by symbol. */
+export function localMembership(
+  tickers: ReadonlyMap<string, TickerRecord>,
+  localCollectionId: string,
+  kind: "watchlist" | "portfolio",
+): Map<string, { ticker: TickerRecord; quantity: number | null }> {
+  const members = new Map<string, { ticker: TickerRecord; quantity: number | null }>();
+  for (const ticker of tickers.values()) {
+    if (kind === "watchlist") {
+      if (ticker.metadata.watchlists.includes(localCollectionId)) {
+        members.set(ticker.metadata.ticker, { ticker, quantity: null });
+      }
+      continue;
+    }
+    if (!ticker.metadata.portfolios.includes(localCollectionId)) continue;
+    const position = ticker.metadata.positions.find((entry) => entry.portfolio === localCollectionId && entry.broker === "manual");
+    members.set(ticker.metadata.ticker, { ticker, quantity: position ? position.shares : null });
+  }
+  return members;
+}
+
+export interface MembershipDiff {
+  add: Array<{ symbol: string; quantity: number | null }>;
+  remove: string[];
+}
+
+/** What changed locally since the last known server set, to push upstream. */
+export function diffMembership(
+  local: ReadonlyMap<string, { quantity: number | null }>,
+  known: ReadonlyMap<string, TeamCollectionItem>,
+): MembershipDiff {
+  const add: MembershipDiff["add"] = [];
+  const remove: string[] = [];
+  for (const [symbol, entry] of local) {
+    const item = known.get(symbol);
+    if (!item || (item.quantity ?? null) !== entry.quantity) add.push({ symbol, quantity: entry.quantity });
+  }
+  for (const symbol of known.keys()) {
+    if (!local.has(symbol)) remove.push(symbol);
+  }
+  return { add, remove };
+}
+
+/** Applies server items to a ticker's metadata for one collection. */
+export function applyMembership(
+  ticker: TickerRecord,
+  localCollectionId: string,
+  kind: "watchlist" | "portfolio",
+  item: TeamCollectionItem | null,
+  currency: string,
+): TickerRecord | null {
+  const metadata = ticker.metadata;
+  if (kind === "watchlist") {
+    const has = metadata.watchlists.includes(localCollectionId);
+    if (!!item === has) return null;
+    return {
+      ...ticker,
+      metadata: {
+        ...metadata,
+        watchlists: item ? [...metadata.watchlists, localCollectionId] : metadata.watchlists.filter((entry) => entry !== localCollectionId),
+      },
+    };
+  }
+  const has = metadata.portfolios.includes(localCollectionId);
+  const position = metadata.positions.find((entry) => entry.portfolio === localCollectionId && entry.broker === "manual");
+  const quantity = item?.quantity ?? null;
+  if (!item) {
+    if (!has && !position) return null;
+    return {
+      ...ticker,
+      metadata: {
+        ...metadata,
+        portfolios: metadata.portfolios.filter((entry) => entry !== localCollectionId),
+        positions: metadata.positions.filter((entry) => entry.portfolio !== localCollectionId),
+      },
+    };
+  }
+  if (has && (position?.shares ?? null) === quantity) return null;
+  const positions = metadata.positions.filter((entry) => entry.portfolio !== localCollectionId);
+  if (quantity !== null) {
+    positions.push({
+      portfolio: localCollectionId,
+      shares: quantity,
+      avgCost: position?.avgCost ?? 0,
+      currency: position?.currency ?? currency,
+      broker: "manual",
+      ...(position?.dateAcquired ? { dateAcquired: position.dateAcquired } : {}),
+    });
+  }
+  return {
+    ...ticker,
+    metadata: {
+      ...metadata,
+      portfolios: has ? metadata.portfolios : [...metadata.portfolios, localCollectionId],
+      positions,
+    },
+  };
+}
+
+export function blankTickerRecord(symbol: string, exchange: string, currency: string): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange,
+      currency,
+      name: symbol,
+      broker_contracts: [],
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}