gloomberb 0.1.0 → 0.3.1

package/src/utils/ticker-metadata.ts

@@ -0,0 +1,51 @@
+import type { TickerMetadata, TickerPosition } from "../types/ticker";
+
+const DEFAULT_TICKER_METADATA: Omit<TickerMetadata, "ticker" | "exchange" | "currency" | "name"> = {
+  portfolios: [],
+  watchlists: [],
+  positions: [],
+  broker_contracts: [],
+  custom: {},
+  tags: [],
+};
+
+function hydratePosition(raw: Record<string, unknown>): TickerPosition {
+  return {
+    portfolio: (raw.portfolio as string) ?? "",
+    shares: (raw.shares as number) ?? 0,
+    avgCost: (raw.avgCost ?? raw.avg_cost) as number ?? 0,
+    currency: (raw.currency as string) ?? undefined,
+    dateAcquired: (raw.dateAcquired ?? raw.date_acquired) as string | undefined,
+    broker: (raw.broker as string) ?? "manual",
+    side: (raw.side as "long" | "short") ?? undefined,
+    marketValue: (raw.marketValue ?? raw.market_value) as number | undefined,
+    unrealizedPnl: (raw.unrealizedPnl ?? raw.unrealized_pnl) as number | undefined,
+    multiplier: (raw.multiplier as number) ?? undefined,
+    markPrice: (raw.markPrice ?? raw.mark_price) as number | undefined,
+    brokerInstanceId: (raw.brokerInstanceId ?? raw.broker_instance_id) as string | undefined,
+    brokerAccountId: (raw.brokerAccountId ?? raw.broker_account_id) as string | undefined,
+    brokerContractId: (raw.brokerContractId ?? raw.broker_contract_id) as number | undefined,
+  };
+}
+
+export function hydrateTickerMetadata(data: Record<string, unknown>): TickerMetadata {
+  const rawPositions = Array.isArray(data.positions) ? data.positions : [];
+  return {
+    ...DEFAULT_TICKER_METADATA,
+    ticker: (data.ticker as string) ?? "",
+    exchange: (data.exchange as string) ?? "",
+    currency: (data.currency as string) ?? "USD",
+    name: (data.name as string) ?? "",
+    sector: data.sector as string | undefined,
+    industry: data.industry as string | undefined,
+    assetCategory: (data.assetCategory ?? data.asset_category) as string | undefined,
+    isin: data.isin as string | undefined,
+    cusip: data.cusip as string | undefined,
+    portfolios: Array.isArray(data.portfolios) ? [...data.portfolios] : [],
+    watchlists: Array.isArray(data.watchlists) ? [...data.watchlists] : [],
+    positions: rawPositions.map((position) => hydratePosition(position as Record<string, unknown>)),
+    broker_contracts: Array.isArray(data.broker_contracts) ? [...data.broker_contracts] : [],
+    custom: data.custom && typeof data.custom === "object" ? { ...(data.custom as Record<string, unknown>) } : {},
+    tags: Array.isArray(data.tags) ? [...data.tags] : [],
+  };
+}

package/src/utils/ticker-search.test.ts

@@ -0,0 +1,227 @@
+import { describe, expect, test } from "bun:test";
+import type { DataProvider } from "../types/data-provider";
+import type { InstrumentSearchResult } from "../types/instrument";
+import type { TickerRecord } from "../types/ticker";
+import { createTestDataProvider } from "../test-support/data-provider";
+import {
+  buildTickerSearchCandidates,
+  createLocalTickerSearchCandidates,
+  findExactTickerSearchMatch,
+  normalizeTickerInput,
+  resolveTickerSearch,
+  searchTickerCandidates,
+  upsertTickerFromSearchResult,
+} from "./ticker-search";
+
+function makeTicker(symbol: string, name = symbol): TickerRecord {
+  return {
+    metadata: {
+      ticker: symbol,
+      exchange: "NASDAQ",
+      currency: "USD",
+      name,
+      portfolios: [],
+      watchlists: [],
+      positions: [],
+      custom: {},
+      tags: [],
+    },
+  };
+}
+
+function makeSearchResult(symbol: string, name = symbol): InstrumentSearchResult {
+  return {
+    providerId: "test",
+    symbol,
+    name,
+    exchange: "NASDAQ",
+    type: "EQUITY",
+  };
+}
+
+function makeDataProvider(results: InstrumentSearchResult[]): DataProvider {
+  return createTestDataProvider({
+    id: "test",
+    search: async () => results,
+  });
+}
+
+describe("ticker-search utilities", () => {
+  test("normalizes explicit and focused ticker inputs", () => {
+    expect(normalizeTickerInput("AAPL", undefined)).toBe("AAPL");
+    expect(normalizeTickerInput("AAPL", " msft ")).toBe("MSFT");
+    expect(normalizeTickerInput(null, undefined)).toBeNull();
+  });
+
+  test("finds exact provider matches for direct ticker resolution", async () => {
+    const tickers = new Map<string, TickerRecord>([["AAPL", makeTicker("AAPL", "Apple")]]);
+    const resolved = await resolveTickerSearch({
+      query: "MSFT",
+      activeTicker: null,
+      tickers,
+      dataProvider: makeDataProvider([
+        makeSearchResult("MSFT", "Microsoft"),
+        makeSearchResult("MSFTW", "Microsoft Warrants"),
+      ]),
+    });
+
+    expect(resolved).toMatchObject({
+      kind: "provider",
+      symbol: "MSFT",
+    });
+  });
+
+  test("combines local and provider candidates without duplicate saved symbols", async () => {
+    const tickers = new Map<string, TickerRecord>([["AAPL", makeTicker("AAPL", "Apple")]]);
+    const results = await searchTickerCandidates({
+      query: "appl",
+      tickers,
+      dataProvider: makeDataProvider([
+        makeSearchResult("AAPL", "Apple Inc"),
+        makeSearchResult("APP", "AppLovin"),
+      ]),
+    });
+
+    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APP"]);
+    expect(findExactTickerSearchMatch(results, "AAPL")?.id).toBe("goto:AAPL");
+  });
+
+  test("uses provider metadata to keep stale saved tickers intuitive in search results", async () => {
+    const tickers = new Map<string, TickerRecord>([["AAPL", makeTicker("AAPL", "AAPL")]]);
+    const results = await searchTickerCandidates({
+      query: "apple",
+      tickers,
+      dataProvider: makeDataProvider([
+        makeSearchResult("AAPL", "Apple Inc"),
+        makeSearchResult("APLE", "Apple Hospitality REIT, Inc."),
+      ]),
+    });
+
+    expect(results.map((item) => item.id)).toEqual(["goto:AAPL", "search:APLE"]);
+    expect(results[0]).toMatchObject({
+      id: "goto:AAPL",
+      detail: "Apple Inc",
+      category: "Saved",
+    });
+    expect(findExactTickerSearchMatch(results, "AAPL")?.id).toBe("goto:AAPL");
+  });
+
+  test("preserves exchange-qualified symbols and groups provider listings intuitively", () => {
+    const results = buildTickerSearchCandidates({
+      query: "apple",
+      tickers: new Map<string, TickerRecord>(),
+      providerResults: [
+        makeSearchResult("AAPL", "Apple Inc"),
+        { ...makeSearchResult("AAPL.BA", "Apple Inc"), exchange: "Buenos Aires" },
+        { ...makeSearchResult("APLY.NE", "Apple Yield Shares Purpose ETF"), exchange: "NEO", type: "ETF" },
+      ],
+      localLimit: 6,
+      totalLimit: 8,
+    });
+
+    expect(results.map((item) => [item.label, item.category])).toEqual([
+      ["AAPL", "Primary Listing"],
+      ["AAPL.BA", "Other Listings"],
+      ["APLY.NE", "Funds & Derivatives"],
+    ]);
+  });
+
+  test("finds exact symbol aliases for dotted share classes", () => {
+    const match = findExactTickerSearchMatch([
+      {
+        id: "search:BRK.B",
+        label: "BRK.B",
+        detail: "Berkshire Hathaway Inc. Class B",
+        kind: "search",
+        category: "Primary Listing",
+        searchAliases: ["BRK.B", "BRK B", "BRKB"],
+      },
+    ], "brkb");
+
+    expect(match?.id).toBe("search:BRK.B");
+  });
+
+  test("expands compact share-class queries when searching providers", async () => {
+    const queries: string[] = [];
+    const expandedResults = await searchTickerCandidates({
+      query: "brkb",
+      tickers: new Map<string, TickerRecord>(),
+      dataProvider: createTestDataProvider({
+        id: "test",
+        search: async (query) => {
+          queries.push(query);
+          return query.toLowerCase() === "brk-b"
+            ? [{ providerId: "test", symbol: "BRK-B", name: "Berkshire Hathaway Inc. Class B", exchange: "NYSE", type: "EQUITY" }]
+            : [];
+        },
+      }),
+      totalLimit: 5,
+    });
+
+    expect(queries).toContain("BRK-B");
+    expect(expandedResults[0]).toMatchObject({
+      label: "BRK-B",
+      category: "Primary Listing",
+    });
+  });
+
+  test("upserts ticker records from provider search results", async () => {
+    const saved: TickerRecord[] = [];
+    const repository = {
+      loadTicker: async () => null,
+      createTicker: async (metadata: TickerRecord["metadata"]) => ({ metadata }),
+      saveTicker: async (ticker: TickerRecord) => {
+        saved.push(ticker);
+      },
+    };
+
+    const { ticker, created } = await upsertTickerFromSearchResult(repository as any, {
+      providerId: "test",
+      symbol: "NVDA",
+      name: "NVIDIA",
+      exchange: "NASDAQ",
+      type: "EQUITY",
+      currency: "USD",
+    });
+
+    expect(created).toBe(true);
+    expect(ticker.metadata.ticker).toBe("NVDA");
+    expect(saved).toHaveLength(0);
+  });
+
+  test("refreshes low-quality saved metadata when opening a provider-backed result", async () => {
+    const existing = makeTicker("AAPL", "AAPL");
+    const saved: TickerRecord[] = [];
+    const repository = {
+      loadTicker: async () => existing,
+      createTicker: async (metadata: TickerRecord["metadata"]) => ({ metadata }),
+      saveTicker: async (ticker: TickerRecord) => {
+        saved.push(ticker);
+      },
+    };
+
+    const { ticker, created } = await upsertTickerFromSearchResult(repository as any, {
+      providerId: "test",
+      symbol: "AAPL",
+      name: "Apple Inc.",
+      exchange: "NASDAQ",
+      type: "EQUITY",
+      currency: "USD",
+    });
+
+    expect(created).toBe(false);
+    expect(ticker.metadata.name).toBe("Apple Inc.");
+    expect(saved).toHaveLength(1);
+  });
+
+  test("exposes local ticker candidates in saved category", () => {
+    expect(createLocalTickerSearchCandidates([makeTicker("TSLA", "Tesla")])).toEqual([
+      expect.objectContaining({
+        id: "goto:TSLA",
+        label: "TSLA",
+        category: "Saved",
+        kind: "ticker",
+      }),
+    ]);
+  });
+});