@adaptic/utils 0.0.959 → 0.0.961

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import adaptic$1, { setTokenProvider, getApolloClient } from '@adaptic/backend-legacy';
+import adaptic$1, { stopClient, setTokenProvider, getApolloClient } from '@adaptic/backend-legacy';
 import { format, sub, set, add, startOfDay, endOfDay, isBefore, differenceInMilliseconds } from 'date-fns';
 import { formatInTimeZone, toZonedTime, fromZonedTime } from 'date-fns-tz';
 import require$$0$4, { EventEmitter } from 'events';
@@ -307,6 +307,22 @@ const fetchAssetOverview = async (symbol) => {
         };
     }
 };
+/**
+ * Gracefully disconnects the shared Apollo client and releases its resources.
+ * Call this during process shutdown to close keep-alive HTTP connections
+ * and drain in-flight operations.
+ *
+ * After calling `disconnectClient()`, the next call to `getSharedApolloClient()`
+ * will create a fresh instance.
+ */
+const disconnectClient = () => {
+    if (apolloClientInstance) {
+        apolloClientInstance = null;
+        getLogger().info("[adaptic] Shared Apollo client reference cleared");
+    }
+    // Delegate to backend-legacy's stopClient() which calls .stop() on the underlying singleton
+    stopClient();
+};
 
 const ANSI_BACKGROUND_OFFSET = 10;
 
@@ -5555,7 +5571,7 @@ const CRYPTO_QUOTE_CURRENCIES$1 = ["USD", "USDT", "USDC", "BTC"];
  * "BTC/USD"). Equity tickers never end with these suffixes because Alpaca
  * equity symbols are plain tickers without a quote currency.
  */
-function isCryptoSymbol$1(symbol) {
+function isCryptoSymbol$2(symbol) {
     if (symbol.includes("/"))
         return true;
     const upper = symbol.toUpperCase();
@@ -5609,7 +5625,7 @@ async function getLatestQuotes$1(auth, params) {
     const equitySymbols = [];
     const cryptoSymbols = [];
     for (const sym of symbols) {
-        if (isCryptoSymbol$1(sym)) {
+        if (isCryptoSymbol$2(sym)) {
             cryptoSymbols.push(sym);
         }
         else {
@@ -5817,7 +5833,7 @@ const CRYPTO_QUOTE_CURRENCIES = ["USD", "USDT", "USDC", "BTC"];
  * "BTC/USD"). Equity tickers never end with these suffixes because Alpaca
  * equity symbols are plain tickers without a quote currency.
  */
-function isCryptoSymbol(symbol) {
+function isCryptoSymbol$1(symbol) {
     if (symbol.includes("/"))
         return true;
     const upper = symbol.toUpperCase();
@@ -5869,7 +5885,7 @@ async function fetchPosition(auth, symbolOrAssetId) {
         const { APIKey, APISecret, type } = await validateAuth(auth);
         const apiBaseUrl = getTradingApiUrl(type);
         // Normalize crypto symbols for Alpaca API compatibility
-        const normalizedSymbol = isCryptoSymbol(symbolOrAssetId)
+        const normalizedSymbol = isCryptoSymbol$1(symbolOrAssetId)
             ? symbolOrAssetId.replace(/[-/]/g, "")
             : symbolOrAssetId;
         const response = await fetch(`${apiBaseUrl}/positions/${normalizedSymbol}`, {
@@ -5906,7 +5922,7 @@ async function fetchPosition(auth, symbolOrAssetId) {
  * @param auth - The authentication details for Alpaca
  * @param symbolOrAssetId - The symbol or asset ID of the position to close
  * @param params - Optional parameters for closing the position
- * @returns The order created to close the position
+ * @returns The order created to close the position, or null if position doesn't exist (404)
  */
 async function closePosition$1(auth, symbolOrAssetId, params) {
     try {
@@ -5915,7 +5931,7 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
         // Normalize crypto symbols for Alpaca API compatibility.
         // Alpaca positions endpoint rejects hyphenated format (e.g., "SOL-USD")
         // but accepts concatenated form (e.g., "SOLUSD").
-        const normalizedSymbol = isCryptoSymbol(symbolOrAssetId)
+        const normalizedSymbol = isCryptoSymbol$1(symbolOrAssetId)
             ? symbolOrAssetId.replace(/[-/]/g, "")
             : symbolOrAssetId;
         const useLimitOrder = params?.useLimitOrder ?? false;
@@ -5931,25 +5947,34 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
             // For crypto, Alpaca stores orders under "SOL/USD" (slash format) but the
             // symbols filter may not match across formats reliably. Fetch all open
             // orders without symbol filter and match client-side via normalization.
-            const openOrders = isCryptoSymbol(symbolOrAssetId)
+            const openOrders = isCryptoSymbol$1(symbolOrAssetId)
                 ? await getOrders$1(auth, { status: "open" })
-                : await getOrders$1(auth, { status: "open", symbols: [normalizedSymbol] });
+                : await getOrders$1(auth, {
+                    status: "open",
+                    symbols: [normalizedSymbol],
+                });
             let cancelledCount = 0;
             for (const order of openOrders) {
                 const orderSymbolNorm = order.symbol.replace(/[-/]/g, "");
                 if (orderSymbolNorm === normalizedSymbol) {
-                    getLogger().info(`Cancelling order ${order.id} (${order.symbol}) for ${normalizedSymbol}`, { account: auth.adapticAccountId || "direct", symbol: normalizedSymbol });
+                    getLogger().info(`Cancelling order ${order.id} (${order.symbol}) for ${normalizedSymbol}`, {
+                        account: auth.adapticAccountId || "direct",
+                        symbol: normalizedSymbol,
+                    });
                     await cancelOrder$1(auth, order.id);
                     cancelledCount++;
                 }
             }
             if (cancelledCount > 0) {
-                getLogger().info(`Cancelled ${cancelledCount} open orders for ${normalizedSymbol}`, { account: auth.adapticAccountId || "direct", symbol: normalizedSymbol });
+                getLogger().info(`Cancelled ${cancelledCount} open orders for ${normalizedSymbol}`, {
+                    account: auth.adapticAccountId || "direct",
+                    symbol: normalizedSymbol,
+                });
             }
         }
         // Crypto positions cannot use limit orders with SIP quotes or time_in_force="day".
         // Use direct DELETE (market order) for crypto regardless of useLimitOrder flag.
-        if (useLimitOrder && !isCryptoSymbol(symbolOrAssetId)) {
+        if (useLimitOrder && !isCryptoSymbol$1(symbolOrAssetId)) {
             // Attempt limit order closure; if quotes are unavailable (after-hours, IEX gaps),
             // fall back to market order (DELETE) so the position still gets closed.
             try {
@@ -5999,7 +6024,9 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
             catch (limitOrderError) {
                 // Quote unavailable or invalid price — fall back to market order (DELETE)
                 // so the position still gets closed rather than leaving it open
-                const errMsg = limitOrderError instanceof Error ? limitOrderError.message : String(limitOrderError);
+                const errMsg = limitOrderError instanceof Error
+                    ? limitOrderError.message
+                    : String(limitOrderError);
                 getLogger().warn(`Limit order closure failed for ${symbolOrAssetId} (${errMsg}), falling back to market order`, {
                     account: auth.adapticAccountId || "direct",
                     symbol: symbolOrAssetId,
@@ -6010,8 +6037,11 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
         }
         // Market order (DELETE) path — used when limit orders are not requested,
         // for crypto symbols, or as a fallback when limit order quotes are unavailable
-        if (isCryptoSymbol(symbolOrAssetId)) {
-            getLogger().info(`Closing crypto position ${normalizedSymbol} via market order (DELETE endpoint)`, { account: auth.adapticAccountId || "direct", symbol: normalizedSymbol });
+        if (isCryptoSymbol$1(symbolOrAssetId)) {
+            getLogger().info(`Closing crypto position ${normalizedSymbol} via market order (DELETE endpoint)`, {
+                account: auth.adapticAccountId || "direct",
+                symbol: normalizedSymbol,
+            });
         }
         const queryParams = new URLSearchParams();
         if (params?.qty !== undefined) {
@@ -6031,6 +6061,15 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
         });
         if (!response.ok) {
             const errorText = await response.text();
+            // Handle 404 (position not found) gracefully - position may have already been closed
+            // or never existed. Return null instead of throwing to allow callers to handle this.
+            if (response.status === 404) {
+                getLogger().info(`Position ${normalizedSymbol} not found in Alpaca (404) - may already be closed`, {
+                    account: auth.adapticAccountId || "direct",
+                    symbol: normalizedSymbol,
+                });
+                return null;
+            }
             throw new Error(`Failed to close position: ${response.status} ${response.statusText} ${errorText}`);
         }
         return (await response.json());
@@ -6078,8 +6117,8 @@ async function closeAllPositions$1(auth, params = { cancel_orders: true, useLimi
             return [];
         }
         // Separate crypto and equity positions — crypto cannot use SIP quotes or time_in_force="day"
-        const equityPositions = allPositions.filter((p) => !isCryptoSymbol(p.symbol));
-        const cryptoPositions = allPositions.filter((p) => isCryptoSymbol(p.symbol));
+        const equityPositions = allPositions.filter((p) => !isCryptoSymbol$1(p.symbol));
+        const cryptoPositions = allPositions.filter((p) => isCryptoSymbol$1(p.symbol));
         getLogger().info(`Found ${allPositions.length} positions to close (${equityPositions.length} equity, ${cryptoPositions.length} crypto)`, { account: auth.adapticAccountId || "direct" });
         // Close crypto positions via direct DELETE (market order) — no SIP quotes needed
         for (const position of cryptoPositions) {
@@ -6102,11 +6141,17 @@ async function closeAllPositions$1(auth, params = { cancel_orders: true, useLimi
                 }
                 else {
                     const errorText = await response.text();
-                    getLogger().warn(`Failed to close crypto position ${position.symbol}: ${response.status} ${errorText}`, { account: auth.adapticAccountId || "direct", symbol: position.symbol });
+                    getLogger().warn(`Failed to close crypto position ${position.symbol}: ${response.status} ${errorText}`, {
+                        account: auth.adapticAccountId || "direct",
+                        symbol: position.symbol,
+                    });
                 }
             }
             catch (cryptoError) {
-                getLogger().warn(`Error closing crypto position ${position.symbol}: ${cryptoError instanceof Error ? cryptoError.message : String(cryptoError)}`, { account: auth.adapticAccountId || "direct", symbol: position.symbol });
+                getLogger().warn(`Error closing crypto position ${position.symbol}: ${cryptoError instanceof Error ? cryptoError.message : String(cryptoError)}`, {
+                    account: auth.adapticAccountId || "direct",
+                    symbol: position.symbol,
+                });
             }
         }
         // Close equity positions via limit orders with SIP quotes
@@ -6199,8 +6244,8 @@ async function closeAllPositionsAfterHours$1(auth, params = { cancel_orders: tru
         return;
     }
     // Separate crypto and equity positions
-    const equityPositions = allPositions.filter((p) => !isCryptoSymbol(p.symbol));
-    const cryptoPositions = allPositions.filter((p) => isCryptoSymbol(p.symbol));
+    const equityPositions = allPositions.filter((p) => !isCryptoSymbol$1(p.symbol));
+    const cryptoPositions = allPositions.filter((p) => isCryptoSymbol$1(p.symbol));
     getLogger().info(`Found ${allPositions.length} positions to close after hours (${equityPositions.length} equity, ${cryptoPositions.length} crypto)`, { account: auth.adapticAccountId || "direct" });
     if (cancel_orders) {
         await cancelAllOrders$1(auth);
@@ -6229,7 +6274,10 @@ async function closeAllPositionsAfterHours$1(auth, params = { cancel_orders: tru
             }
             else {
                 const errorText = await response.text();
-                getLogger().warn(`Failed to close crypto position ${position.symbol}: ${response.status} ${errorText}`, { account: auth.adapticAccountId || "direct", symbol: position.symbol });
+                getLogger().warn(`Failed to close crypto position ${position.symbol}: ${response.status} ${errorText}`, {
+                    account: auth.adapticAccountId || "direct",
+                    symbol: position.symbol,
+                });
             }
         }
         catch (cryptoError) {
@@ -7871,6 +7919,84 @@ const massiveLimit = pLimit(MASSIVE_CONCURRENCY_LIMIT);
  * request settles, so subsequent calls after resolution make a fresh request.
  */
 const fetchLastTradeInflight = new Map();
+/**
+ * Check if a symbol is a crypto pair based on common patterns.
+ * Crypto symbols typically end in USD, USDT, USDC, or contain a hyphen with USD.
+ * Examples: BTCUSD, BTC-USD, BTC/USD, LINKUSD, SOL-USD
+ *
+ * @param symbol - The ticker symbol to check
+ * @returns True if the symbol appears to be a crypto pair
+ */
+function isCryptoSymbol(symbol) {
+    // Pattern: ends with USD/USDT/USDC and has 3-4 letter base (e.g., BTCUSD, LINKUSD)
+    if (/^[A-Z]{2,5}(USD[TC]?)$/i.test(symbol)) {
+        return true;
+    }
+    // Pattern: contains hyphen or slash with USD (e.g., BTC-USD, BTC/USD)
+    if (/^[A-Z]{2,5}[-/]USD[TC]?$/i.test(symbol)) {
+        return true;
+    }
+    // Pattern: already has X: prefix (e.g., X:BTC-USD)
+    if (symbol.startsWith("X:")) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Normalize a symbol for the Massive.com API.
+ * Crypto symbols must be prefixed with "X:" and use hyphen format (e.g., X:BTC-USD).
+ * Stock symbols are passed through unchanged.
+ *
+ * @param symbol - The raw ticker symbol
+ * @returns The symbol formatted for Massive.com API
+ */
+function normalizeMassiveSymbol(symbol) {
+    // If already has X: prefix, ensure hyphen format
+    if (symbol.startsWith("X:")) {
+        return symbol;
+    }
+    // Check if it's a crypto symbol
+    if (!isCryptoSymbol(symbol)) {
+        return symbol; // Stock symbol - return unchanged
+    }
+    // Normalize crypto symbol to X:BASE-QUOTE format
+    // Handle formats: BTCUSD, BTC-USD, BTC/USD -> X:BTC-USD
+    let base;
+    let quote;
+    if (symbol.includes("-")) {
+        // Format: BTC-USD
+        const parts = symbol.split("-");
+        base = parts[0];
+        quote = parts.slice(1).join("-");
+    }
+    else if (symbol.includes("/")) {
+        // Format: BTC/USD
+        const parts = symbol.split("/");
+        base = parts[0];
+        quote = parts.slice(1).join("/");
+    }
+    else {
+        // Format: BTCUSD - need to extract base and quote
+        // Common quote currencies: USD, USDT, USDC
+        if (symbol.endsWith("USDT")) {
+            base = symbol.slice(0, -4);
+            quote = "USDT";
+        }
+        else if (symbol.endsWith("USDC")) {
+            base = symbol.slice(0, -4);
+            quote = "USDC";
+        }
+        else if (symbol.endsWith("USD")) {
+            base = symbol.slice(0, -3);
+            quote = "USD";
+        }
+        else {
+            // Unknown format, return as-is
+            return symbol;
+        }
+    }
+    return `X:${base.toUpperCase()}-${quote.toUpperCase()}`;
+}
 // Use to update general information about stocks
 /**
  * Fetches general information about a stock ticker.
@@ -7992,7 +8118,9 @@ const fetchLastTradeImpl = async (symbol, options) => {
     }
     const apiKey = options?.apiKey || MASSIVE_API_KEY;
     validateMassiveApiKey$1(apiKey);
-    const baseUrl = `https://api.massive.com/v3/trades/${encodeURIComponent(symbol)}`;
+    // Normalize crypto symbols to Massive.com API format (e.g., LINK-USD -> X:LINK-USD)
+    const normalizedSymbol = normalizeMassiveSymbol(symbol);
+    const baseUrl = `https://api.massive.com/v3/trades/${encodeURIComponent(normalizedSymbol)}`;
     const params = new URLSearchParams({
         apiKey,
         limit: "1",
@@ -8028,9 +8156,10 @@ const fetchLastTradeImpl = async (symbol, options) => {
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-            const contextualMessage = `Error fetching last trade for ${symbol}`;
+            const contextualMessage = `Error fetching last trade for ${symbol}${normalizedSymbol !== symbol ? ` (normalized: ${normalizedSymbol})` : ""}`;
             getLogger().error(`${contextualMessage}: ${errorMessage}`, {
                 symbol,
+                normalizedSymbol,
                 errorType: error instanceof Error && error.message.includes("AUTH_ERROR")
                     ? "AUTH_ERROR"
                     : error instanceof Error && error.message.includes("RATE_LIMIT")
@@ -8725,10 +8854,11 @@ const calculateFees = async (action, trade, alpacaAccount) => {
 };
 const computeTotalFees = async (trade) => {
     let totalFees = 0;
-    // fetch alpaca account details using adaptic.alpacaAccount.get({id: trade.alpacaAccountId})
+    // Use the shared singleton Apollo client to avoid creating orphaned connections
+    const client = await getSharedApolloClient();
     const alpacaAccount = (await adaptic$1.alpacaAccount.get({
         id: trade.alpacaAccountId,
-    }));
+    }, client));
     if (!alpacaAccount)
         return totalFees;
     const feePromises = trade?.actions?.map((action) => calculateFees(action, trade, alpacaAccount));
@@ -67783,6 +67913,7 @@ const adaptic = {
         getApolloClient: getSharedApolloClient,
         configureAuth: configureAuth,
         isAuthConfigured: isAuthConfigured,
+        disconnectClient: disconnectClient,
     },
     alpaca: {
         // New SDK-based client factory (RECOMMENDED)