@icgio/icg-exchanges-wrapper 1.14.226 → 1.14.228

package/lib/order-status-store.js

@@ -0,0 +1,318 @@
+const { Pool } = require('pg')
+
+/**
+ * Async PostgreSQL store for order status
+ * Non-blocking: all writes are fire-and-forget to avoid blocking the main process
+ */
+class OrderStatusStore {
+  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('OrderStatusStore pool error:', err.message)
+      })
+
+      await this.ensure_table()
+      this.enabled = true
+      this.start_flush_interval()
+      console.log('OrderStatusStore initialized successfully')
+    } catch (err) {
+      console.error('OrderStatusStore init failed:', err.message)
+      this.enabled = false
+    }
+  }
+
+  async ensure_table() {
+    const create_table_query = `
+      CREATE TABLE IF NOT EXISTS order_status (
+        id SERIAL PRIMARY KEY,
+        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),
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        UNIQUE(exchange, pair, type, order_id, status, created_at)
+      );
+      CREATE INDEX IF NOT EXISTS idx_order_status_exchange_pair ON order_status(exchange, pair);
+      CREATE INDEX IF NOT EXISTS idx_order_status_order_id ON order_status(order_id);
+      CREATE INDEX IF NOT EXISTS idx_order_status_created_at ON order_status(created_at);
+      CREATE INDEX IF NOT EXISTS idx_order_status_status ON order_status(status);
+    `
+
+    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('OrderStatusStore 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
+
+    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: data.open_time || null,
+      close_time: data.close_time || null,
+      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 insert_query = `
+      INSERT INTO order_status (
+        exchange, pair, type, order_id, order_type, status,
+        price, amount, f_amount, f_percentage, t_amount,
+        fees, open_time, close_time, note
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
+      ON CONFLICT (exchange, pair, type, order_id, status, created_at) DO NOTHING
+    `
+
+    const client = await this.pool.connect()
+    try {
+      for (const record of batch) {
+        await client.query(insert_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()
+    }
+  }
+
+  /**
+   * Query order status history
+   * @param {object} filters - { exchange, pair, order_id, status, limit, offset }
+   * @returns {Promise<Array>}
+   */
+  async query(filters = {}) {
+    if (!this.enabled || !this.table_ready) {
+      return []
+    }
+
+    const conditions = []
+    const params = []
+    let param_index = 1
+
+    if (filters.exchange) {
+      conditions.push(`exchange = $${param_index++}`)
+      params.push(filters.exchange)
+    }
+    if (filters.pair) {
+      conditions.push(`pair = $${param_index++}`)
+      params.push(filters.pair)
+    }
+    if (filters.order_id) {
+      conditions.push(`order_id = $${param_index++}`)
+      params.push(filters.order_id)
+    }
+    if (filters.status) {
+      conditions.push(`status = $${param_index++}`)
+      params.push(filters.status)
+    }
+    if (filters.from_time) {
+      conditions.push(`created_at >= $${param_index++}`)
+      params.push(filters.from_time)
+    }
+    if (filters.to_time) {
+      conditions.push(`created_at <= $${param_index++}`)
+      params.push(filters.to_time)
+    }
+
+    const where_clause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : ''
+    const limit = filters.limit || 100
+    const offset = filters.offset || 0
+
+    const query_str = `
+      SELECT * FROM order_status
+      ${where_clause}
+      ORDER BY created_at DESC
+      LIMIT ${limit} OFFSET ${offset}
+    `
+
+    const client = await this.pool.connect()
+    try {
+      const result = await client.query(query_str, params)
+      return result.rows
+    } finally {
+      client.release()
+    }
+  }
+
+  /**
+   * Get aggregated stats for orders
+   * @param {object} filters - { exchange, pair, from_time, to_time }
+   * @returns {Promise<object>}
+   */
+  async get_stats(filters = {}) {
+    if (!this.enabled || !this.table_ready) {
+      return null
+    }
+
+    const conditions = []
+    const params = []
+    let param_index = 1
+
+    if (filters.exchange) {
+      conditions.push(`exchange = $${param_index++}`)
+      params.push(filters.exchange)
+    }
+    if (filters.pair) {
+      conditions.push(`pair = $${param_index++}`)
+      params.push(filters.pair)
+    }
+    if (filters.from_time) {
+      conditions.push(`created_at >= $${param_index++}`)
+      params.push(filters.from_time)
+    }
+    if (filters.to_time) {
+      conditions.push(`created_at <= $${param_index++}`)
+      params.push(filters.to_time)
+    }
+
+    const where_clause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : ''
+
+    const query_str = `
+      SELECT 
+        status,
+        COUNT(*) as count,
+        SUM(COALESCE(f_amount, 0)) as total_filled_amount
+      FROM order_status
+      ${where_clause}
+      GROUP BY status
+    `
+
+    const client = await this.pool.connect()
+    try {
+      const result = await client.query(query_str, params)
+      return result.rows.reduce((acc, row) => {
+        acc[row.status] = {
+          count: parseInt(row.count, 10),
+          total_filled_amount: parseFloat(row.total_filled_amount) || 0,
+        }
+        return acc
+      }, {})
+    } finally {
+      client.release()
+    }
+  }
+
+  async close() {
+    this.stop_flush_interval()
+    if (this.queue.length > 0) {
+      try {
+        await this.flush()
+      } catch (err) {
+        console.error('OrderStatusStore final flush error:', err.message)
+      }
+    }
+    if (this.pool) {
+      await this.pool.end()
+    }
+    this.enabled = false
+  }
+}
+
+module.exports = OrderStatusStore

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 OrderStatusStore = 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 OrderStatusStore(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,6 +756,9 @@ 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) {
     this.order_info[exchange][pair][type] = _.omit(this.order_info[exchange][pair][type], [order_id])

package/package.json

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