@icgio/icg-exchanges-wrapper 1.14.227 → 1.14.229

package/lib/order-status-store.js

@@ -0,0 +1,233 @@
+const { Pool } = require('pg')
+
+/**
+ * Async PostgreSQL store for open orders
+ * Non-blocking: all writes are fire-and-forget to avoid blocking the main process
+ */
+class OpenOrdersStore {
+  constructor(connection_string) {
+    this.enabled = true
+    this.pool = null
+    this.table_ready = false
+    this.queue = []
+    this.max_queue_size = 2000
+    this.flush_interval = null
+    this.flush_interval_ms = 5000
+
+    if (connection_string) {
+      this.init(connection_string)
+    }
+  }
+
+  async init(connection_string) {
+    try {
+      this.pool = new Pool({
+        connectionString: connection_string,
+        max: 5,
+        idleTimeoutMillis: 30000,
+        connectionTimeoutMillis: 5000,
+        ssl: { rejectUnauthorized: false },
+      })
+
+      this.pool.on('error', (err) => {
+        console.error('OpenOrdersStore pool error:', err.message)
+      })
+
+      // Set timezone to UTC for all connections
+      this.pool.on('connect', async (client) => {
+        await client.query("SET timezone = 'UTC'")
+      })
+
+      await this.ensure_table()
+      this.enabled = true
+      this.start_flush_interval()
+      console.log('OpenOrdersStore initialized successfully')
+    } catch (err) {
+      console.error('OpenOrdersStore init failed:', err.message)
+      this.enabled = false
+    }
+  }
+
+  async ensure_table() {
+    const create_table_query = `
+      CREATE TABLE IF NOT EXISTS open_orders (
+        exchange VARCHAR(64) NOT NULL,
+        pair VARCHAR(32) NOT NULL,
+        order_type VARCHAR(64),
+        type VARCHAR(16) NOT NULL,
+        order_id VARCHAR(128) NOT NULL,
+        status VARCHAR(32) NOT NULL,
+        price DECIMAL(32, 16),
+        amount DECIMAL(32, 16),
+        f_amount DECIMAL(32, 16),
+        f_percentage DECIMAL(8, 4),
+        t_amount DECIMAL(32, 16),
+        fees JSONB,
+        open_time TIMESTAMPTZ,
+        close_time TIMESTAMPTZ,
+        note VARCHAR(256),
+        updated_at TIMESTAMPTZ DEFAULT (NOW() AT TIME ZONE 'UTC'),
+        PRIMARY KEY (exchange, pair, type, order_id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_open_orders_status ON open_orders(status);
+      CREATE INDEX IF NOT EXISTS idx_open_orders_exchange ON open_orders(exchange);
+    `
+
+    const client = await this.pool.connect()
+    try {
+      await client.query(create_table_query)
+      this.table_ready = true
+    } finally {
+      client.release()
+    }
+  }
+
+  start_flush_interval() {
+    if (this.flush_interval) return
+
+    this.flush_interval = setInterval(() => {
+      this.flush().catch((err) => {
+        console.error('OpenOrdersStore flush error:', err.message)
+      })
+    }, this.flush_interval_ms)
+  }
+
+  stop_flush_interval() {
+    if (this.flush_interval) {
+      clearInterval(this.flush_interval)
+      this.flush_interval = null
+    }
+  }
+
+  /**
+   * Queue an order status update (non-blocking)
+   * @param {string} exchange
+   * @param {string} pair
+   * @param {string} type - 'buy' or 'sell'
+   * @param {string} order_id
+   * @param {object} data - order data
+   * @param {string} note - update note
+   */
+  store(exchange, pair, type, order_id, data, note) {
+    if (!this.enabled) return
+
+    // Convert Date objects to UTC ISO strings for consistent timezone handling
+    const to_utc_iso = (date) => {
+      if (!date) return null
+      if (date instanceof Date) {
+        return date.toISOString()
+      }
+      return date
+    }
+
+    const record = {
+      exchange,
+      pair,
+      type,
+      order_id: order_id,
+      order_type: data.order_type || null,
+      status: data.status || null,
+      price: data.price || null,
+      amount: data.amount || null,
+      f_amount: data.f_amount || null,
+      f_percentage: data.f_percentage || null,
+      t_amount: data.t_amount || null,
+      fees: data.fees ? JSON.stringify(data.fees) : null,
+      open_time: to_utc_iso(data.open_time),
+      close_time: to_utc_iso(data.close_time),
+      note: note || null,
+    }
+
+    this.queue.push(record)
+
+    // Prevent memory overflow
+    if (this.queue.length > this.max_queue_size) {
+      this.queue.shift()
+    }
+  }
+
+  /**
+   * Flush queued records to database (async, non-blocking to caller)
+   */
+  async flush() {
+    if (!this.enabled || !this.table_ready || this.queue.length === 0) return
+
+    const batch = this.queue.splice(0, 100) // Process up to 100 at a time
+
+    const upsert_query = `
+      INSERT INTO open_orders (
+        exchange, pair, type, order_id, order_type, status,
+        price, amount, f_amount, f_percentage, t_amount,
+        fees, open_time, close_time, note, updated_at
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, (NOW() AT TIME ZONE 'UTC'))
+      ON CONFLICT (exchange, pair, type, order_id) DO UPDATE SET
+        order_type = EXCLUDED.order_type,
+        status = EXCLUDED.status,
+        price = EXCLUDED.price,
+        amount = EXCLUDED.amount,
+        f_amount = EXCLUDED.f_amount,
+        f_percentage = EXCLUDED.f_percentage,
+        t_amount = EXCLUDED.t_amount,
+        fees = EXCLUDED.fees,
+        open_time = EXCLUDED.open_time,
+        close_time = EXCLUDED.close_time,
+        note = EXCLUDED.note,
+        updated_at = (NOW() AT TIME ZONE 'UTC')
+    `
+
+    const delete_query = `
+      DELETE FROM open_orders 
+      WHERE exchange = $1 AND pair = $2 AND type = $3 AND order_id = $4
+    `
+
+    const client = await this.pool.connect()
+    try {
+      for (const record of batch) {
+        if (record.status === 'DELETED') {
+          await client.query(delete_query, [record.exchange, record.pair, record.type, record.order_id])
+        } else {
+          await client.query(upsert_query, [
+            record.exchange,
+            record.pair,
+            record.type,
+            record.order_id,
+            record.order_type,
+            record.status,
+            record.price,
+            record.amount,
+            record.f_amount,
+            record.f_percentage,
+            record.t_amount,
+            record.fees,
+            record.open_time,
+            record.close_time,
+            record.note,
+          ])
+        }
+      }
+    } catch (err) {
+      // Re-queue failed records
+      this.queue.unshift(...batch)
+      throw err
+    } finally {
+      client.release()
+    }
+  }
+
+  async close() {
+    this.stop_flush_interval()
+    if (this.queue.length > 0) {
+      try {
+        await this.flush()
+      } catch (err) {
+        console.error('OpenOrdersStore final flush error:', err.message)
+      }
+    }
+    if (this.pool) {
+      await this.pool.end()
+    }
+    this.enabled = false
+  }
+}
+
+module.exports = OpenOrdersStore

package/middleware/orders.js

@@ -7,6 +7,7 @@ const utils = require('@icgio/icg-utils').utils
 const { coinmarketcap: get_coinmarketcap_rates, observable: Observable } = require('@icgio/icg-utils')
 
 const Account = require('./account.js')
+const OpenOrdersStore = require('../lib/order-status-store.js')
 
 // Default precision functions - will be overridden if provided in settings
 let round_price = (exchange, pair, price) => price
@@ -124,6 +125,8 @@ module.exports = class Orders {
     this.accounting_benchmark = settings.accounting_benchmark
     this.balance_benchmark = settings.balance_benchmark || {}
     this.min_reserve_balance = settings.min_reserve_balance || {}
+    // Initialize order status store for PostgreSQL persistence (async, non-blocking)
+    this.order_status_store = new OpenOrdersStore(cd.order_status_store_connection_string)
     for (let exchange in exchange_pairs) {
       let api_key_temp = cd[exchange]['api_keys'] || cd[exchange]['api_key'],
         secret_key_temp = cd[exchange]['secret_keys'] || cd[exchange]['secret_key'],
@@ -753,10 +756,16 @@ module.exports = class Orders {
       console.log(`f_filled_orders_info:${exchange},${pair},${type},${order_id},${price},${amount},${f_amount},${t_amount},${fees},${close_time},${note}`)
     }
     // end: log every f-filled trade for future analysis
+    // Store order status to PostgreSQL asynchronously (non-blocking)
+    const order_data = _.get(this.order_info, [exchange, pair, type, order_id], {})
+    this.order_status_store.store(exchange, pair, type, order_id, order_data, note)
   }
   delete_order_info(exchange, pair, type, order_id, note) {
+    const order_data = _.get(this.order_info, [exchange, pair, type, order_id], {})
     this.order_info[exchange][pair][type] = _.omit(this.order_info[exchange][pair][type], [order_id])
     console.log('DELETE %s: %s %s %s %s', note, exchange, pair, type, order_id)
+    // Store deletion to PostgreSQL (non-blocking)
+    this.order_status_store.store(exchange, pair, type, order_id, { ...order_data, status: 'DELETED' }, note)
   }
   check_balances() {
     let balances_handler = (exchange, res) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icgio/icg-exchanges-wrapper",
-  "version": "1.14.227",
+  "version": "1.14.229",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -17,9 +17,10 @@
   },
   "homepage": "https://github.com/icgio/icg-exchanges-wrapper#readme",
   "dependencies": {
-    "@icgio/icg-exchanges": "^1.32.118",
+    "@icgio/icg-exchanges": "^1.32.119",
     "@icgio/icg-utils": "^1.9.38",
     "lodash": "^4.17.20",
+    "pg": "^8.13.1",
     "uuid": "^11.1.0"
   }
 }