@discomedia/utils 1.0.52 → 1.0.54

package/dist/index.mjs

@@ -11381,6 +11381,7 @@ function requireConstants () {
 
 	constants = {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT: 30000,
 	  EMPTY_BUFFER: Buffer.alloc(0),
 	  GUID: '258EAFA5-E914-47DA-95CA-C5AB0DC85B11',
 	  hasBlob,
@@ -14151,6 +14152,7 @@ function requireWebsocket () {
 
 	const {
 	  BINARY_TYPES,
+	  CLOSE_TIMEOUT,
 	  EMPTY_BUFFER,
 	  GUID,
 	  kForOnEventAttribute,
@@ -14165,7 +14167,6 @@ function requireWebsocket () {
 	const { format, parse } = requireExtension();
 	const { toBuffer } = requireBufferUtil();
 
-	const closeTimeout = 30 * 1000;
 	const kAborted = Symbol('kAborted');
 	const protocolVersions = [8, 13];
 	const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
@@ -14221,6 +14222,7 @@ function requireWebsocket () {
 	      initAsClient(this, address, protocols, options);
 	    } else {
 	      this._autoPong = options.autoPong;
+	      this._closeTimeout = options.closeTimeout;
 	      this._isServer = true;
 	    }
 	  }
@@ -14762,6 +14764,8 @@ function requireWebsocket () {
 	 *     times in the same tick
 	 * @param {Boolean} [options.autoPong=true] Specifies whether or not to
 	 *     automatically send a pong in response to a ping
+	 * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to wait
+	 *     for the closing handshake to finish after `websocket.close()` is called
 	 * @param {Function} [options.finishRequest] A function which can be used to
 	 *     customize the headers of each http request before it is sent
 	 * @param {Boolean} [options.followRedirects=false] Whether or not to follow
@@ -14788,6 +14792,7 @@ function requireWebsocket () {
 	  const opts = {
 	    allowSynchronousEvents: true,
 	    autoPong: true,
+	    closeTimeout: CLOSE_TIMEOUT,
 	    protocolVersion: protocolVersions[1],
 	    maxPayload: 100 * 1024 * 1024,
 	    skipUTF8Validation: false,
@@ -14806,6 +14811,7 @@ function requireWebsocket () {
 	  };
 
 	  websocket._autoPong = opts.autoPong;
+	  websocket._closeTimeout = opts.closeTimeout;
 
 	  if (!protocolVersions.includes(opts.protocolVersion)) {
 	    throw new RangeError(
@@ -15423,7 +15429,7 @@ function requireWebsocket () {
 	function setCloseTimer(websocket) {
 	  websocket._closeTimer = setTimeout(
 	    websocket._socket.destroy.bind(websocket._socket),
-	    closeTimeout
+	    websocket._closeTimeout
 	  );
 	}
 
@@ -15441,23 +15447,23 @@ function requireWebsocket () {
 
 	  websocket._readyState = WebSocket.CLOSING;
 
-	  let chunk;
-
 	  //
 	  // The close frame might not have been received or the `'end'` event emitted,
 	  // for example, if the socket was destroyed due to an error. Ensure that the
 	  // `receiver` stream is closed after writing any remaining buffered data to
 	  // it. If the readable side of the socket is in flowing mode then there is no
-	  // buffered data as everything has been already written and `readable.read()`
-	  // will return `null`. If instead, the socket is paused, any possible buffered
-	  // data will be read as a single chunk.
+	  // buffered data as everything has been already written. If instead, the
+	  // socket is paused, any possible buffered data will be read as a single
+	  // chunk.
 	  //
 	  if (
 	    !this._readableState.endEmitted &&
 	    !websocket._closeFrameReceived &&
 	    !websocket._receiver._writableState.errorEmitted &&
-	    (chunk = websocket._socket.read()) !== null
+	    this._readableState.length !== 0
 	  ) {
+	    const chunk = this.read(this._readableState.length);
+
 	    websocket._receiver.write(chunk);
 	  }
 
@@ -15789,7 +15795,7 @@ function requireWebsocketServer () {
 	const PerMessageDeflate = requirePermessageDeflate();
 	const subprotocol = requireSubprotocol();
 	const WebSocket = requireWebsocket();
-	const { GUID, kWebSocket } = requireConstants();
+	const { CLOSE_TIMEOUT, GUID, kWebSocket } = requireConstants();
 
 	const keyRegex = /^[+/0-9A-Za-z]{22}==$/;
 
@@ -15816,6 +15822,9 @@ function requireWebsocketServer () {
 	   *     pending connections
 	   * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
 	   *     track clients
+	   * @param {Number} [options.closeTimeout=30000] Duration in milliseconds to
+	   *     wait for the closing handshake to finish after `websocket.close()` is
+	   *     called
 	   * @param {Function} [options.handleProtocols] A hook to handle protocols
 	   * @param {String} [options.host] The hostname where to bind the server
 	   * @param {Number} [options.maxPayload=104857600] The maximum allowed message
@@ -15845,6 +15854,7 @@ function requireWebsocketServer () {
 	      perMessageDeflate: false,
 	      handleProtocols: null,
 	      clientTracking: true,
+	      closeTimeout: CLOSE_TIMEOUT,
 	      verifyClient: null,
 	      noServer: false,
 	      backlog: null, // use default (511 as implemented in net.js)
@@ -18129,7 +18139,7 @@ class AlpacaTradingAPI {
     }
     handleTradeUpdate(data) {
         if (this.tradeUpdateCallback) {
-            this.log(`Trade update: ${data.event} to ${data.order.side} ${data.order.qty} shares, type ${data.order.type}`, {
+            this.log(`Trade update: ${data.event} to ${data.order.side} ${data.order.qty} shares${data.event === 'partial_fill' ? ` (filled shares: ${data.order.filled_qty})` : ''}, type ${data.order.type}`, {
                 symbol: data.order.symbol,
                 type: 'debug',
             });
@@ -18247,7 +18257,9 @@ class AlpacaTradingAPI {
                 try {
                     this.ws.terminate();
                 }
-                catch { /* no-op */ }
+                catch {
+                    /* no-op */
+                }
             }
             this.ws = null;
         }
@@ -18464,6 +18476,7 @@ class AlpacaTradingAPI {
      * @param qty (number) - the quantity of the order
      * @param side (string) - the side of the order
      * @param position_intent (string) - the position intent of the order. Important for knowing if a position needs a trailing stop.
+     * @param client_order_id (string) - optional client order id
      */
     async createMarketOrder(symbol, qty, side, position_intent, client_order_id) {
         this.log(`Creating market order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
@@ -18489,6 +18502,86 @@ class AlpacaTradingAPI {
             throw error;
         }
     }
+    /**
+     * Create a Market on Open (MOO) order - executes in the opening auction
+     *
+     * IMPORTANT TIMING CONSTRAINTS:
+     * - Valid submission window: After 7:00pm ET and before 9:28am ET
+     * - Orders submitted between 9:28am and 7:00pm ET will be REJECTED
+     * - Orders submitted after 7:00pm ET are queued for the next trading day's opening auction
+     * - Example: An order at 8:00pm Monday will execute at Tuesday's market open (9:30am)
+     *
+     * @param symbol - The symbol of the order
+     * @param qty - The quantity of shares
+     * @param side - Buy or sell
+     * @param position_intent - The position intent (buy_to_open, sell_to_close, etc.)
+     * @param client_order_id - Optional client order id
+     * @returns The created order
+     */
+    async createMOOOrder(symbol, qty, side, position_intent, client_order_id) {
+        this.log(`Creating Market on Open order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            type: 'market',
+            time_in_force: 'opg',
+            order_class: 'simple',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest('/orders', 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating MOO order: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
+    /**
+     * Create a Market on Close (MOC) order - executes in the closing auction
+     *
+     * IMPORTANT TIMING CONSTRAINTS:
+     * - Valid submission window: After 7:00pm ET (previous day) and before 3:50pm ET (same day)
+     * - Orders submitted between 3:50pm and 7:00pm ET will be REJECTED
+     * - Orders submitted after 7:00pm ET are queued for the next trading day's closing auction
+     * - Example: An order at 8:00pm Monday will execute at Tuesday's market close (4:00pm)
+     *
+     * @param symbol - The symbol of the order
+     * @param qty - The quantity of shares
+     * @param side - Buy or sell
+     * @param position_intent - The position intent (buy_to_open, sell_to_close, etc.)
+     * @param client_order_id - Optional client order id
+     * @returns The created order
+     */
+    async createMOCOrder(symbol, qty, side, position_intent, client_order_id) {
+        this.log(`Creating Market on Close order for ${symbol}: ${side} ${qty} shares (${position_intent})`, {
+            symbol,
+        });
+        const body = {
+            symbol,
+            qty: Math.abs(qty).toString(),
+            side,
+            position_intent,
+            type: 'market',
+            time_in_force: 'cls',
+            order_class: 'simple',
+        };
+        if (client_order_id !== undefined) {
+            body.client_order_id = client_order_id;
+        }
+        try {
+            return await this.makeRequest('/orders', 'POST', body);
+        }
+        catch (error) {
+            this.log(`Error creating MOC order: ${error}`, { type: 'error' });
+            throw error;
+        }
+    }
     /**
      * Get the current trail percent for a symbol, assuming that it has an open position and a trailing stop order to close it. Because this relies on an orders request for one symbol, you can't do it too often.
      * @param symbol (string) - the symbol of the order
@@ -18806,7 +18899,7 @@ class AlpacaTradingAPI {
         const hourlyParams = { timeframe: '1Min', period: '1D' };
         const [dailyHistory, hourlyHistory] = await Promise.all([
             this.getPortfolioHistory(dailyParams),
-            this.getPortfolioHistory(hourlyParams)
+            this.getPortfolioHistory(hourlyParams),
         ]);
         // If no hourly history, return daily as-is
         if (!hourlyHistory.timestamp || hourlyHistory.timestamp.length === 0) {