@riocrypto/common-server 1.0.2926 → 1.0.2928

package/build/helpers/get-order-from-reference.js

@@ -8,72 +8,140 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getOrderFromReference = void 0;
 const order_1 = require("../models/order");
 const common_1 = require("@riocrypto/common");
+// A reference is 8 hex characters of the order id (two from the random bytes
+// plus the last six); older orders were referenced by the last six alone. The
+// payer types it into a concepto that can carry anything else around it, so
+// matching has always been "does the text contain the token", and that is what
+// is preserved here.
+const NEW_FORMAT_LENGTH = 8;
+const OLD_FORMAT_LENGTH = 6;
+// Statuses a payment can no longer be applied to. Anything failed is included
+// by name so that a status added later is excluded without a change here.
+const excludedStatuses = Object.values(common_1.OrderStatus).filter((status) => {
+    const statusLower = status.toLowerCase();
+    return (statusLower === "complete" ||
+        statusLower === "cancelled" ||
+        statusLower === "expired" ||
+        statusLower === "refundcomplete" ||
+        statusLower.includes("failed"));
+});
+const HEX_DIGITS = "0123456789abcdef";
+// Every window of `length` hex characters in the text, lowercase and in the
+// order they appear. A reference has to be a run of hex, so anything else in
+// the concepto is a boundary rather than a candidate.
+const hexWindows = (text, length) => {
+    var _a;
+    const windows = new Set();
+    for (const run of (_a = text.toLowerCase().match(/[0-9a-f]+/g)) !== null && _a !== void 0 ? _a : []) {
+        for (let i = 0; i + length <= run.length; i += 1) {
+            windows.add(run.slice(i, i + length));
+        }
+    }
+    return Array.from(windows);
+};
+// A concepto is short, so a bound this size is never reached by a real payment.
+// It is here so that a pathological text cannot turn the old-format fallback
+// into a query with tens of thousands of keys.
+const MAX_OLD_FORMAT_WINDOWS = 24;
 const getOrderFromReference = (reference, mongoose) => __awaiter(void 0, void 0, void 0, function* () {
-    // Ensure reference is defined
+    var _a, e_1, _b, _c;
     if (!reference) {
         throw new Error("Invalid reference. Reference cannot be empty.");
     }
-    // Convert reference to lowercase to ensure case-insensitive comparison
-    const referenceText = reference.toLowerCase();
     const Order = (0, order_1.buildOrder)(mongoose);
-    // Define statuses to exclude (completed, cancelled, and any failed status)
-    const excludedStatuses = Object.values(common_1.OrderStatus).filter((status) => {
-        const statusLower = status.toLowerCase();
-        return (statusLower === "complete" ||
-            statusLower === "cancelled" ||
-            statusLower === "expired" ||
-            statusLower === "refundcomplete" ||
-            statusLower.includes("failed"));
-    });
-    // Process in batches to avoid memory issues
-    const batchSize = 1000;
-    let skip = 0;
-    let foundOrder = null;
-    let foundOrderOldFormat = null;
-    while (!foundOrder) {
-        // Query only active orders (exclude completed/cancelled/failed) in batches
-        const orders = yield Order.find({
-            status: { $nin: excludedStatuses },
-        })
-            .select("_id") // Only select the ID field to minimize memory usage
-            .skip(skip)
-            .limit(batchSize)
-            .lean(); // Use lean() for better performance
-        // If no more orders, break the loop
-        if (orders.length === 0) {
-            break;
+    const activeStatus = { $nin: excludedStatuses };
+    // New format, exact and indexed. The stored reference is what the customer was
+    // shown, upper case, so the windows are compared the same way.
+    const newFormatCandidates = hexWindows(reference, NEW_FORMAT_LENGTH).map((window) => window.toUpperCase());
+    if (newFormatCandidates.length) {
+        const order = yield Order.findOne({
+            "paymentInstructions.reference": { $in: newFormatCandidates },
+            status: activeStatus,
+        }).sort({ createdAt: 1 });
+        if (order) {
+            return order;
         }
-        // Check each order ID against the reference
-        // Priority 1: New format - 2 chars from random portion (8-9) + last 6 chars
-        // Priority 2: Old format - just last 6 chars (backwards compatibility)
-        for (const order of orders) {
-            const orderId = order._id.toString().toLowerCase();
-            const randomPrefix = orderId.slice(8, 10);
-            const last6 = orderId.slice(-6);
-            const reference8Chars = randomPrefix + last6;
-            // Check new 8-char format first (takes priority)
-            if (referenceText.includes(reference8Chars)) {
-                foundOrder = yield Order.findById(order._id);
-                break;
+    }
+    const oldFormatWindows = hexWindows(reference, OLD_FORMAT_LENGTH).slice(0, MAX_OLD_FORMAT_WINDOWS);
+    // Buy orders that were never given a stored reference, from before the bank
+    // payment listener wrote one. Only these are still compared against the id in
+    // code. Walked once, with a cursor over a bounded query rather than paging
+    // through every active order with skip, and before the old-format lookup so a
+    // full match here still beats a six-character one anywhere, as it always has.
+    const newFormatWindowSet = new Set(newFormatCandidates.map((candidate) => candidate.toLowerCase()));
+    const oldFormatWindowSet = new Set(oldFormatWindows);
+    let legacyOldFormatMatchId = null;
+    const legacyOrders = Order.find({
+        status: activeStatus,
+        side: common_1.Side.Buy,
+        "paymentInstructions.reference": { $exists: false },
+    })
+        .select("_id")
+        .lean()
+        .cursor();
+    try {
+        for (var _d = true, legacyOrders_1 = __asyncValues(legacyOrders), legacyOrders_1_1; legacyOrders_1_1 = yield legacyOrders_1.next(), _a = legacyOrders_1_1.done, !_a;) {
+            _c = legacyOrders_1_1.value;
+            _d = false;
+            try {
+                const legacy = _c;
+                const orderId = legacy._id.toString().toLowerCase();
+                const reference8Chars = orderId.slice(8, 10) + orderId.slice(-6);
+                if (newFormatWindowSet.has(reference8Chars)) {
+                    return Order.findById(legacy._id);
+                }
+                if (!legacyOldFormatMatchId && oldFormatWindowSet.has(orderId.slice(-6))) {
+                    legacyOldFormatMatchId = legacy._id;
+                }
             }
-            // Track old 6-char format match as fallback (only if no 8-char match yet)
-            if (!foundOrderOldFormat && referenceText.includes(last6)) {
-                foundOrderOldFormat = yield Order.findById(order._id);
+            finally {
+                _d = true;
             }
         }
-        skip += batchSize;
     }
-    // Use 8-char match if found, otherwise fall back to 6-char match
-    if (!foundOrder && foundOrderOldFormat) {
-        foundOrder = foundOrderOldFormat;
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = legacyOrders_1.return)) yield _b.call(legacyOrders_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    // Old format: the payer typed only the last six characters. Those are also the
+    // last six of a stored new-format reference, so each six-character window is
+    // widened to every two-character prefix it could sit behind and looked up on
+    // the same index. 256 keys per window keeps this a point lookup rather than a
+    // scan, which a regex with a leading wildcard could not be.
+    if (oldFormatWindows.length) {
+        const oldFormatCandidates = [];
+        for (const window of oldFormatWindows) {
+            for (const first of HEX_DIGITS) {
+                for (const second of HEX_DIGITS) {
+                    oldFormatCandidates.push((first + second + window).toUpperCase());
+                }
+            }
+        }
+        const order = yield Order.findOne({
+            "paymentInstructions.reference": { $in: oldFormatCandidates },
+            status: activeStatus,
+        }).sort({ createdAt: 1 });
+        if (order) {
+            return order;
+        }
     }
-    if (!foundOrder) {
-        throw new Error("Order not found");
+    if (legacyOldFormatMatchId) {
+        return Order.findById(legacyOldFormatMatchId);
     }
-    return foundOrder;
+    throw new Error("Order not found");
 });
 exports.getOrderFromReference = getOrderFromReference;

package/build/models/order.js

@@ -412,6 +412,11 @@ const buildOrder = (mongoose) => {
     orderSchema.index({ status: 1, createdAt: 1 });
     orderSchema.index({ clientReferenceId: 1 }, { sparse: true });
     orderSchema.index({ "paymentsReceived.blockchainTxId": 1 }, { sparse: true });
+    // Every inbound bank deposit is matched to its order by the reference the
+    // customer typed. Before this, that meant loading every active order and
+    // comparing ids in code on each webhook, which under a burst of payments held
+    // the fintoc pod long enough for its liveness probe to kill it mid-deposit.
+    orderSchema.index({ "paymentInstructions.reference": 1 }, { sparse: true });
     // At most one order per real quoteId. Imported orders use quoteId "" and are
     // excluded by the partial filter (which also serves the createOrder lookup).
     orderSchema.index({ quoteId: 1 }, { unique: true, partialFilterExpression: { quoteId: { $gt: "" } } });

package/build/services/logger.d.ts

@@ -25,6 +25,7 @@ declare class LoggerService {
     private setupConsoleMasking;
     private setupStreamMasking;
     getLogger(): Logger;
+    private gcpSeverity;
     initLogger(): Promise<void>;
 }
 declare const loggerService: LoggerService;

package/build/services/logger.js

@@ -278,6 +278,22 @@ class LoggerService {
             // Bearer tokens: Bearer <token>
             /(\bBearer\s+)([^\s,;"]+)/gi,
         ];
+        // Cloud Logging reads a top level "severity" field from JSON stdout lines.
+        // Without it every stdout line is stored as INFO and stderr as ERROR.
+        this.gcpSeverity = (0, winston_1.format)((info) => {
+            var _a;
+            const severities = {
+                error: "ERROR",
+                warn: "WARNING",
+                info: "INFO",
+                http: "INFO",
+                verbose: "DEBUG",
+                debug: "DEBUG",
+                silly: "DEBUG",
+            };
+            info.severity = (_a = severities[info.level]) !== null && _a !== void 0 ? _a : "DEFAULT";
+            return info;
+        });
         this.logger = null;
         this.setupConsoleMasking();
         this.setupStreamMasking();
@@ -453,11 +469,16 @@ class LoggerService {
                     service: process.env.OTEL_SERVICE_NAME,
                 }));
             }
+            // One JSON line per log event. prettyPrint spreads each event over many
+            // stdout lines and Cloud Logging stores and bills every line as its own
+            // entry with roughly 800 bytes of metadata, which multiplied ingestion
+            // volume by 7x to 25x depending on the service.
+            const outputFormat = process.env.RIO_ENV === common_1.RioEnv.Local ? winston_1.format.prettyPrint() : winston_1.format.json();
             this.logger = (0, winston_1.createLogger)({
                 level: logLevel,
                 format: winston_1.format.combine(winston_1.format.timestamp(), this.maskSensitiveData(), this.requestMethodFilter(), // Add the request method filter
                 this.handleCustomErrorFormat(), // Add the custom error format
-                winston_1.format.json(), winston_1.format.prettyPrint()),
+                this.gcpSeverity(), outputFormat),
                 transports: transportsArray,
             });
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riocrypto/common-server",
-  "version": "1.0.2926",
+  "version": "1.0.2928",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",