@adaptic/utils 0.0.997 → 0.0.999

package/dist/index.cjs

@@ -4299,6 +4299,15 @@ const API_RETRY_CONFIGS = {
 };
 
 const limitPriceSlippagePercent100 = 0.1; // 0.1%
+/**
+ * Alpaca's maximum page size for GET /orders — also our explicit default.
+ * Alpaca's silent server-side default is 50, which truncates order
+ * visibility on protective-stop / qty-reservation paths; we never let it
+ * apply (mirrors ORDER_CHUNK_SIZE in src/alpaca/legacy/orders.ts).
+ */
+const ORDER_PAGE_LIMIT = 500;
+/** Delay between order pagination pages to stay clear of rate limits. */
+const ORDER_PAGINATION_DELAY_MS = 300;
 /**
 Websocket example
   const alpacaAPI = createAlpacaTradingAPI(credentials); // type AlpacaCredentials
@@ -4634,10 +4643,25 @@ class AlpacaTradingAPI {
         return positions;
     }
     /**
-     * Get all orders
+     * Get all orders, with explicit paging.
+     *
+     * When `params.limit` is provided it is treated as a caller-controlled cap
+     * and a single request is made (preserves the previous contract for
+     * callers that run their own page walks, e.g. phantom-order lookup).
+     *
+     * When `limit` is omitted, Alpaca's silent server-side default of 50
+     * records is NOT allowed to apply — that default truncated open-order
+     * visibility on protective-stop and qty-reservation paths. Instead the
+     * API maximum (500) is requested explicitly and, whenever a full page
+     * comes back, the result is paginated with a `submitted_at` cursor walk
+     * (`until` for desc — the default — or `after` for asc) until a short
+     * page indicates the window is exhausted. Pages are deduplicated by
+     * order id so same-timestamp boundary orders can never be double
+     * counted, and the walk terminates if a full page yields no new orders.
+     *
      * @param params (GetOrdersParams) - optional parameters to filter the orders
      * - status: 'open' | 'closed' | 'all'
-     * - limit: number
+     * - limit: number — caller-controlled cap; disables pagination
      * - after: string
      * - until: string
      * - direction: 'asc' | 'desc'
@@ -4647,11 +4671,54 @@ class AlpacaTradingAPI {
      * @returns all orders
      */
     async getOrders(params = {}) {
+        if (params.limit !== undefined) {
+            return this.fetchOrdersPage(params, params.limit);
+        }
+        const isAsc = params.direction === "asc";
+        const allOrders = [];
+        const seenOrderIds = new Set();
+        // Moving cursor: `until` walks backwards for desc (the default),
+        // `after` walks forwards for asc. Both are exclusive on Alpaca's side.
+        let cursor = isAsc ? params.after : params.until;
+        while (true) {
+            const pageParams = {
+                ...params,
+                ...(isAsc ? { after: cursor } : { until: cursor }),
+            };
+            const page = await this.fetchOrdersPage(pageParams, ORDER_PAGE_LIMIT);
+            let addedCount = 0;
+            for (const order of page) {
+                if (!seenOrderIds.has(order.id)) {
+                    seenOrderIds.add(order.id);
+                    allOrders.push(order);
+                    addedCount++;
+                }
+            }
+            // Short page = window exhausted (same termination as legacy getOrders).
+            if (page.length < ORDER_PAGE_LIMIT)
+                break;
+            const lastOrder = page[page.length - 1];
+            // No usable cursor, or a full page of already-seen orders (cursor not
+            // advancing): stop rather than risk an unbounded walk.
+            if (!lastOrder.submitted_at || addedCount === 0)
+                break;
+            cursor = lastOrder.submitted_at;
+            await new Promise((resolve) => setTimeout(resolve, ORDER_PAGINATION_DELAY_MS));
+        }
+        return allOrders;
+    }
+    /**
+     * Issues a single GET /orders request with an explicit `limit` so
+     * Alpaca's silent 50-record server default can never apply.
+     * @param params - order filter parameters (limit is supplied separately)
+     * @param limit - explicit page size to request
+     * @returns one page of orders
+     */
+    async fetchOrdersPage(params, limit) {
         const queryParams = new URLSearchParams();
         if (params.status)
             queryParams.append("status", params.status);
-        if (params.limit)
-            queryParams.append("limit", params.limit.toString());
+        queryParams.append("limit", limit.toString());
         if (params.after)
             queryParams.append("after", params.after);
         if (params.until)
@@ -4664,9 +4731,10 @@ class AlpacaTradingAPI {
             queryParams.append("symbols", params.symbols.join(","));
         if (params.side)
             queryParams.append("side", params.side);
-        const endpoint = `/orders${queryParams.toString() ? `?${queryParams.toString()}` : ""}`;
+        const endpoint = `/orders?${queryParams.toString()}`;
         try {
-            return await this.makeRequest(endpoint);
+            const orders = await this.makeRequest(endpoint);
+            return orders ?? [];
         }
         catch (error) {
             this.log(`Error getting orders: ${error}`, { type: "error" });
@@ -5691,12 +5759,49 @@ class AlpacaTradingAPI {
 
 /**
  * Resolves AlpacaAuth into validated API credentials.
- * Supports authentication via adapticAccountId or direct API key/secret.
+ *
+ * Credential precedence (broker connectivity must never depend on the CRUD
+ * backend when the caller already holds valid broker credentials):
+ *
+ * 1. **Inline credentials** — when BOTH `alpacaApiKey` and `alpacaApiSecret`
+ *    are present and non-empty AND the account `type` is known (either
+ *    `auth.type` is set, or there is no `adapticAccountId` to resolve it
+ *    from, in which case `type` defaults to `"PAPER"`), the inline values
+ *    are used directly with NO backend round trip. This keeps broker
+ *    exits/cancels possible when backend-legacy is degraded and removes
+ *    the per-call GraphQL credential refetch from the exit path.
+ * 2. **adapticAccountId lookup** — used only when inline credentials are
+ *    absent/empty, or when inline credentials lack an explicit `type` and
+ *    an `adapticAccountId` is available to resolve the authoritative
+ *    PAPER/LIVE type (a wrong type would route requests to the wrong
+ *    Alpaca host). The lookup is a no-cache GraphQL round trip to
+ *    backend-legacy via `adaptic.alpacaAccount.get`.
+ *
  * @param auth - The authentication details for Alpaca
  * @returns Validated authentication credentials
  * @throws Error if authentication details are missing or invalid
  */
 async function validateAuth(auth) {
+    const inlineKey = auth.alpacaApiKey && auth.alpacaApiKey.trim().length > 0
+        ? auth.alpacaApiKey
+        : undefined;
+    const inlineSecret = auth.alpacaApiSecret && auth.alpacaApiSecret.trim().length > 0
+        ? auth.alpacaApiSecret
+        : undefined;
+    // Prefer inline credentials whenever the account type is unambiguous:
+    // either the caller supplied it, or there is no adapticAccountId to
+    // resolve the authoritative type from anyway.
+    if (inlineKey && inlineSecret && (auth.type || !auth.adapticAccountId)) {
+        const accountType = auth.type || "PAPER";
+        validateAlpacaCredentials({
+            apiKey: inlineKey,
+            apiSecret: inlineSecret});
+        return {
+            APIKey: inlineKey,
+            APISecret: inlineSecret,
+            type: accountType,
+        };
+    }
     if (auth.adapticAccountId) {
         const client = await getSharedApolloClient();
         const alpacaAccount = (await adaptic$1.alpacaAccount.get({
@@ -5716,17 +5821,6 @@ async function validateAuth(auth) {
             type: alpacaAccount.type,
         };
     }
-    else if (auth.alpacaApiKey && auth.alpacaApiSecret) {
-        const accountType = auth.type || "PAPER";
-        validateAlpacaCredentials({
-            apiKey: auth.alpacaApiKey,
-            apiSecret: auth.alpacaApiSecret});
-        return {
-            APIKey: auth.alpacaApiKey,
-            APISecret: auth.alpacaApiSecret,
-            type: accountType,
-        };
-    }
     throw new Error("Either adapticAccountId or both alpacaApiKey and alpacaApiSecret must be provided");
 }
 
@@ -7000,11 +7094,33 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
                             status: "open",
                             symbols: [normalizedSymbol],
                         });
-                    // Orders stuck in pending_cancel / pending_replace are already
-                    // terminalising (or wedged — see the 42210000 handling above);
-                    // waiting longer will not change them, so they must not make
-                    // the verification spin to exhaustion on every close attempt.
-                    const remainingOrders = allRemainingOrders.filter((o) => o.status !== "pending_cancel" && o.status !== "pending_replace");
+                    // pending_cancel / pending_replace handling needs an age split
+                    // (2026-06-10 live evidence, both directions):
+                    //   - FRESH pending (entered the state < 30s ago): the broker is
+                    //     mid-terminalisation and STILL HOLDS the order's quantity.
+                    //     Treating it as done made the close fire early and bounce
+                    //     with 403 40310000 "insufficient qty available" (META/WFC
+                    //     closes at 17:07Z), so it must stay in `remainingOrders`
+                    //     and keep the verification loop waiting.
+                    //   - STALE pending (>= 30s): a wedged zombie (observed 8 days
+                    //     on one order) that will never terminalise — waiting spins
+                    //     the loop to exhaustion on every close attempt, so it is
+                    //     excluded and the close proceeds; the broker arbitrates the
+                    //     held quantity.
+                    const WEDGED_PENDING_AGE_MS = 30_000;
+                    const remainingOrders = allRemainingOrders.filter((o) => {
+                        if (o.status !== "pending_cancel" &&
+                            o.status !== "pending_replace") {
+                            return true;
+                        }
+                        const updatedAtMs = Date.parse(o.updated_at ?? "");
+                        if (!Number.isFinite(updatedAtMs)) {
+                            // No usable timestamp — conservatively treat as fresh so the
+                            // loop waits rather than racing the broker's qty release.
+                            return true;
+                        }
+                        return Date.now() - updatedAtMs < WEDGED_PENDING_AGE_MS;
+                    });
                     if (remainingOrders.length === 0) {
                         getLogger().info(`Cancel verification passed for ${normalizedSymbol} (attempt ${attempt}/${maxVerifyAttempts})`, {
                             account: auth.adapticAccountId || "direct",
@@ -7109,6 +7225,10 @@ async function closePosition$1(auth, symbolOrAssetId, params) {
                 "APCA-API-KEY-ID": APIKey,
                 "APCA-API-SECRET-KEY": APISecret,
             },
+            // The close submission must never hang indefinitely (hung sockets on
+            // NAT idle-reap stall the exit in exactly the fast-tape scenario
+            // where it matters) — bound it like every other call in this file.
+            signal: createTimeoutSignal(DEFAULT_TIMEOUTS.ALPACA_API),
         });
         if (!response.ok) {
             const errorText = await response.text();
@@ -7183,6 +7303,7 @@ async function closeAllPositions$1(auth, params = { cancel_orders: true, useLimi
                         "APCA-API-KEY-ID": APIKey,
                         "APCA-API-SECRET-KEY": APISecret,
                     },
+                    signal: createTimeoutSignal(DEFAULT_TIMEOUTS.ALPACA_API),
                 });
                 if (response.ok) {
                     getLogger().info(`Closed crypto position ${position.symbol} via market order`, {
@@ -7316,6 +7437,7 @@ async function closeAllPositionsAfterHours$1(auth, params = { cancel_orders: tru
                     "APCA-API-KEY-ID": APIKey,
                     "APCA-API-SECRET-KEY": APISecret,
                 },
+                signal: createTimeoutSignal(DEFAULT_TIMEOUTS.ALPACA_API),
             });
             if (response.ok) {
                 getLogger().info(`Closed crypto position ${position.symbol} via market order`, {