elpaypg 0.0.0-stage → 2.0.1

package/src/vendor/db/repositories/device.repository.js

@@ -0,0 +1,285 @@
+import crypto from 'node:crypto';
+import { blindIndex, blindIndexMatches, safeEqual, issueDeviceCredential, verifyDeviceCredential } from '../../common/index.js';
+
+/** Namespace so device-token digests never collide with other blind indexes. */
+const INDEX_NS = 'devtok';
+
+export class DeviceRepository {
+  /**
+   * @param {import('../database.js').Database} db
+   */
+  constructor(db) {
+    this.db = db;
+  }
+
+  /**
+   * Creates or registers a new device record.
+   * @param {{
+   *   id?: string,
+   *   customerId?: string|null,
+   *   publicKey: string,
+   *   fingerprintHash: string,
+   *   userAgent?: string,
+   *   platform?: string,
+   *   browser?: string,
+   *   timezone?: string,
+   *   language?: string,
+   *   screenSignature?: string,
+   *   deviceToken?: string,
+   *   status?: string
+   * }} data
+   */
+  create(data) {
+    const id = data.id || `dev_${crypto.randomUUID()}`;
+    const deviceToken = data.deviceToken || issueDeviceCredential(id);
+    const now = new Date().toISOString();
+    const status = data.status || 'ACTIVE';
+
+    const sql = `
+      INSERT INTO devices (
+        id, customer_id, public_key, fingerprint_hash, user_agent,
+        platform, browser, timezone, language, screen_signature,
+        device_token, status, created_at, last_seen_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `;
+
+    this.db.execute(sql, [
+      id,
+      data.customerId || null,
+      data.publicKey,
+      data.fingerprintHash,
+      data.userAgent || null,
+      data.platform || null,
+      data.browser || null,
+      data.timezone || null,
+      data.language || null,
+      data.screenSignature || null,
+      // Only a keyed blind index is persisted: the raw token is never needed again and a
+      // database dump must not yield usable device credentials.
+      blindIndex(deviceToken, INDEX_NS),
+      status,
+      now,
+      now
+    ]);
+
+    // The plaintext token is returned here and only here: it is issued to the registering
+    // client once. Persisted storage keeps only the keyed blind index.
+    const created = this.findById(id);
+    return created ? { ...created, deviceToken } : null;
+  }
+
+  /**
+   * Finds a device by its unique ID.
+   * @param {string} id
+   */
+  findById(id) {
+    if (!id) return null;
+    const row = this.db.queryOne('SELECT * FROM devices WHERE id = ?', [id]);
+    return row ? this.mapRow(row) : null;
+  }
+
+  /**
+   * Verifies a presented device token for a specific device ID in constant time.
+   * @param {string} deviceId
+   * @param {string} presentedToken
+   * @returns {boolean}
+   */
+  verifyToken(deviceId, presentedToken) {
+    if (!deviceId || typeof deviceId !== 'string' || !presentedToken || typeof presentedToken !== 'string') {
+      return false;
+    }
+    const row = this.db.queryOne(
+      'SELECT id, device_token, status FROM devices WHERE id = ?',
+      [deviceId]
+    );
+    if (!row || row.status !== 'ACTIVE' || !row.device_token) {
+      return false;
+    }
+
+    // If token uses the server-signed envelope (`devtok_<deviceId>...`), verify its HMAC signature too.
+    if (presentedToken.startsWith(`devtok_${deviceId}.`) && !verifyDeviceCredential(deviceId, presentedToken)) {
+      return false;
+    }
+
+    if (blindIndexMatches(presentedToken, row.device_token, INDEX_NS)) {
+      return true;
+    }
+
+    // Support legacy rows that stored the raw token prior to blind indexing, and upgrade them.
+    if (safeEqual(presentedToken, row.device_token)) {
+      try {
+        this.db.execute('UPDATE devices SET device_token = ? WHERE id = ?', [blindIndex(presentedToken, INDEX_NS), row.id]);
+      } catch {}
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Rotates and issues a fresh server-signed device credential for an existing device.
+   * @param {string} deviceId
+   * @returns {string|null}
+   */
+  rotateToken(deviceId) {
+    if (!deviceId) return null;
+    const row = this.db.queryOne('SELECT id, status FROM devices WHERE id = ?', [deviceId]);
+    if (!row || row.status !== 'ACTIVE') return null;
+    const freshToken = issueDeviceCredential(deviceId);
+    const now = new Date().toISOString();
+    this.db.execute(
+      'UPDATE devices SET device_token = ?, last_seen_at = ? WHERE id = ?',
+      [blindIndex(freshToken, INDEX_NS), now, deviceId]
+    );
+    return freshToken;
+  }
+
+  /**
+   * Finds a device by its active device token.
+   * @param {string} token
+   */
+  findByToken(token) {
+    if (!token) return null;
+    let row = this.db.queryOne(
+      'SELECT * FROM devices WHERE device_token = ? AND status = ?',
+      [blindIndex(token, INDEX_NS), 'ACTIVE']
+    );
+    // Rows written before index-only storage held the raw token; re-index on first use.
+    if (!row && typeof token === 'string' && token.startsWith('devtok_')) {
+      const legacy = this.db.queryOne(
+        'SELECT * FROM devices WHERE device_token = ? AND status = ?',
+        [token, 'ACTIVE']
+      );
+      if (legacy) {
+        try {
+          this.db.execute('UPDATE devices SET device_token = ? WHERE id = ?', [blindIndex(token, INDEX_NS), legacy.id]);
+        } catch {}
+        row = legacy;
+      }
+    }
+    return row ? this.mapRow(row) : null;
+  }
+
+  /**
+   * Finds existing device by matching public key.
+   * @param {string} publicKey
+   */
+  findByPublicKey(publicKey) {
+    if (!publicKey) return null;
+    const row = this.db.queryOne('SELECT * FROM devices WHERE public_key = ? LIMIT 1', [publicKey]);
+    return row ? this.mapRow(row) : null;
+  }
+
+  /**
+   * Finds existing device by customerId and fingerprint.
+   * @param {string} customerId
+   * @param {string} fingerprintHash
+   */
+  findByCustomerAndFingerprint(customerId, fingerprintHash) {
+    if (!customerId || !fingerprintHash) return null;
+    const row = this.db.queryOne(
+      'SELECT * FROM devices WHERE customer_id = ? AND fingerprint_hash = ? AND status = "ACTIVE" LIMIT 1',
+      [customerId, fingerprintHash]
+    );
+    return row ? this.mapRow(row) : null;
+  }
+
+  /**
+   * Finds all devices registered for a customer.
+   * @param {string} customerId
+   */
+  findByCustomerId(customerId) {
+    if (!customerId) return [];
+    const rows = this.db.query(
+      'SELECT * FROM devices WHERE customer_id = ? ORDER BY last_seen_at DESC',
+      [customerId]
+    );
+    return rows.map(r => this.mapRow(r));
+  }
+
+  /**
+   * Associates an existing device with a customer.
+   * @param {string} deviceId
+   * @param {string} customerId
+   */
+  associateCustomer(deviceId, customerId) {
+    const now = new Date().toISOString();
+    this.db.execute(
+      'UPDATE devices SET customer_id = ?, last_seen_at = ? WHERE id = ?',
+      [customerId, now, deviceId]
+    );
+    return this.findById(deviceId);
+  }
+
+  /**
+   * Updates last seen timestamp for a device.
+   * @param {string} deviceId
+   */
+  touch(deviceId) {
+    if (!deviceId) return;
+    try {
+      this.db.execute(
+        'UPDATE devices SET last_seen_at = ? WHERE id = ?',
+        [new Date().toISOString(), deviceId]
+      );
+    } catch {}
+  }
+
+  /**
+   * Updates device record.
+   * @param {string} id
+   * @param {Partial<any>} data
+   */
+  update(id, data) {
+    const fields = [];
+    const values = [];
+
+    if (data.customerId !== undefined) {
+      fields.push('customer_id = ?');
+      values.push(data.customerId);
+    }
+    if (data.fingerprintHash !== undefined) {
+      fields.push('fingerprint_hash = ?');
+      values.push(data.fingerprintHash);
+    }
+    if (data.status !== undefined) {
+      fields.push('status = ?');
+      values.push(data.status);
+    }
+    if (data.deviceToken !== undefined) {
+      fields.push('device_token = ?');
+      values.push(blindIndex(data.deviceToken, INDEX_NS));
+    }
+
+    fields.push('last_seen_at = ?');
+    values.push(new Date().toISOString());
+
+    values.push(id);
+    this.db.execute(`UPDATE devices SET ${fields.join(', ')} WHERE id = ?`, values);
+    return this.findById(id);
+  }
+
+  /**
+   * Maps a database row to a clean camelCase object.
+   * @param {any} row
+   */
+  mapRow(row) {
+    return {
+      id: row.id,
+      customerId: row.customer_id,
+      publicKey: row.public_key,
+      fingerprintHash: row.fingerprint_hash,
+      userAgent: row.user_agent,
+      platform: row.platform,
+      browser: row.browser,
+      timezone: row.timezone,
+      language: row.language,
+      screenSignature: row.screen_signature,
+      // Omitted: this column now holds a keyed blind index, not a usable credential.
+      deviceToken: null,
+      status: row.status,
+      createdAt: new Date(row.created_at),
+      lastSeenAt: new Date(row.last_seen_at)
+    };
+  }
+}

package/src/vendor/db/repositories/merchant.repository.js

@@ -0,0 +1,158 @@
+import crypto from 'node:crypto';
+import { encryptAtRest, decryptAtRest } from '../../common/index.js';
+
+/** Gmail OAuth credentials are nested inside `branding.gmailConfig`; encrypt just those. */
+const GMAIL_SECRET_FIELDS = ['clientSecret', 'refreshToken', 'apiKey'];
+
+/** Serializes branding, encrypting any nested Gmail OAuth secrets. */
+function serializeBranding(branding) {
+  if (!branding || typeof branding !== 'object') return branding || '{"primaryColor":"#2563eb","appName":"ELPAY PG","logoUrl":null}';
+  const copy = { ...branding };
+  const gmail = copy.gmailConfig;
+  if (gmail && typeof gmail === 'object') {
+    const enc = { ...gmail };
+    for (const field of GMAIL_SECRET_FIELDS) {
+      if (enc[field]) enc[field] = encryptAtRest(enc[field]);
+    }
+    copy.gmailConfig = enc;
+  }
+  return JSON.stringify(copy);
+}
+
+/** Reverses serializeBranding. Plaintext values written earlier pass through unchanged. */
+function deserializeBranding(raw) {
+  const branding = JSON.parse(raw || '{}');
+  const gmail = branding.gmailConfig;
+  if (gmail && typeof gmail === 'object') {
+    const dec = { ...gmail };
+    for (const field of GMAIL_SECRET_FIELDS) {
+      if (dec[field]) dec[field] = decryptAtRest(dec[field]);
+    }
+    branding.gmailConfig = dec;
+  }
+  return branding;
+}
+
+export class MerchantRepository {
+  /**
+   * @param {import('../database.js').Database} db
+   */
+  constructor(db) {
+    this.db = db;
+  }
+
+  /**
+   * Creates a new merchant record.
+   */
+  create(data) {
+    const id = data.id || crypto.randomUUID();
+    const branding = typeof data.branding === 'object'
+      ? serializeBranding(data.branding)
+      : (data.branding || '{"primaryColor":"#2563eb","appName":"ELPAY PG","logoUrl":null}');
+    const now = new Date().toISOString();
+
+    const sql = `
+      INSERT INTO merchants (id, business_name, slug, contact_email, contact_phone, webhook_url, webhook_secret, branding, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `;
+
+    this.db.execute(sql, [
+      id,
+      data.businessName,
+      data.slug,
+      data.contactEmail,
+      data.contactPhone,
+      data.webhookUrl || null,
+      // Webhook HMAC key must be recoverable at signing time, so it is encrypted at rest.
+      encryptAtRest(data.webhookSecret || crypto.randomBytes(32).toString('hex')),
+      branding,
+      now,
+      now
+    ]);
+
+    return this.findById(id);
+  }
+
+  findById(id) {
+    const row = this.db.queryOne('SELECT * FROM merchants WHERE id = ?', [id]);
+    if (!row) return null;
+    return this.mapRow(row);
+  }
+
+  findBySlug(slug) {
+    const row = this.db.queryOne('SELECT * FROM merchants WHERE slug = ?', [slug]);
+    if (!row) return null;
+    return this.mapRow(row);
+  }
+
+  getDefault() {
+    const canonical = this.findById('00000000-0000-0000-0000-000000000001');
+    if (canonical) return canonical;
+    const all = this.findAll();
+    return all[0] || null;
+  }
+
+  findAll() {
+    const rows = this.db.query(`
+      SELECT * FROM merchants 
+      ORDER BY CASE WHEN id = '00000000-0000-0000-0000-000000000001' THEN 0 ELSE 1 END, created_at ASC
+    `);
+    return rows.map(r => this.mapRow(r));
+  }
+
+  update(id, updates) {
+    const fields = [];
+    const params = [];
+
+    if (updates.businessName !== undefined) {
+      fields.push('business_name = ?');
+      params.push(updates.businessName);
+    }
+    if (updates.contactEmail !== undefined) {
+      fields.push('contact_email = ?');
+      params.push(updates.contactEmail);
+    }
+    if (updates.contactPhone !== undefined) {
+      fields.push('contact_phone = ?');
+      params.push(updates.contactPhone);
+    }
+    if (updates.webhookUrl !== undefined) {
+      fields.push('webhook_url = ?');
+      params.push(updates.webhookUrl);
+    }
+    if (updates.webhookSecret !== undefined) {
+      fields.push('webhook_secret = ?');
+      params.push(encryptAtRest(updates.webhookSecret));
+    }
+    if (updates.branding !== undefined) {
+      fields.push('branding = ?');
+      params.push(typeof updates.branding === 'object' ? serializeBranding(updates.branding) : updates.branding);
+    }
+
+    if (fields.length === 0) return this.findById(id);
+
+    fields.push('updated_at = ?');
+    params.push(new Date().toISOString());
+
+    params.push(id);
+    this.db.execute(`UPDATE merchants SET ${fields.join(', ')} WHERE id = ?`, params);
+
+    return this.findById(id);
+  }
+
+  mapRow(row) {
+    return {
+      id: row.id,
+      businessName: row.business_name,
+      slug: row.slug,
+      contactEmail: row.contact_email,
+      contactPhone: row.contact_phone,
+      webhookUrl: row.webhook_url,
+      // Plaintext rows written before encryption existed decrypt to themselves.
+      webhookSecret: decryptAtRest(row.webhook_secret),
+      branding: deserializeBranding(row.branding),
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+}

package/src/vendor/db/repositories/observation.repository.js

@@ -0,0 +1,124 @@
+import crypto from 'node:crypto';
+import { ObservationAttributionStatus } from '../../common/index.js';
+
+export class ObservationRepository {
+  /**
+   * @param {import('../database.js').Database} db
+   */
+  constructor(db) {
+    this.db = db;
+  }
+
+  create(data) {
+    const id = data.id || crypto.randomUUID();
+    const now = new Date().toISOString();
+    const rawPayload = typeof data.rawPayload === 'object' ? JSON.stringify(data.rawPayload) : (data.rawPayload || '{}');
+
+    const sql = `
+      INSERT INTO payment_observations (
+        id, receiving_account_id, source, amount_paise, observed_at,
+        ingested_at, sender_vpa, bank_reference_number, fingerprint_hash,
+        raw_payload, attribution_status, attributed_payment_id, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `;
+
+    this.db.execute(sql, [
+      id,
+      data.receivingAccountId,
+      data.source,
+      Number(data.amountPaise),
+      data.observedAt.toISOString(),
+      now,
+      data.senderVpa || null,
+      data.bankReferenceNumber || null,
+      data.fingerprintHash,
+      rawPayload,
+      data.attributionStatus || ObservationAttributionStatus.UNATTRIBUTED,
+      data.attributedPaymentId || null,
+      now
+    ]);
+
+    return this.findById(id);
+  }
+
+  findById(id) {
+    const row = this.db.queryOne('SELECT * FROM payment_observations WHERE id = ?', [id]);
+    if (!row) return null;
+    return this.mapRow(row);
+  }
+
+  findByFingerprint(fingerprintHash) {
+    const row = this.db.queryOne('SELECT * FROM payment_observations WHERE fingerprint_hash = ?', [fingerprintHash]);
+    if (!row) return null;
+    return this.mapRow(row);
+  }
+
+  findUnattributed(receivingAccountId) {
+    const rows = this.db.query(`
+      SELECT * FROM payment_observations
+      WHERE receiving_account_id = ? AND attribution_status = ?
+      ORDER BY observed_at ASC
+    `, [receivingAccountId, ObservationAttributionStatus.UNATTRIBUTED]);
+
+    return rows.map(r => this.mapRow(r));
+  }
+
+  findByReceivingAccount(receivingAccountId, limit = 50) {
+    const rows = this.db.query(`
+      SELECT * FROM payment_observations
+      WHERE receiving_account_id = ?
+      ORDER BY observed_at DESC
+      LIMIT ?
+    `, [receivingAccountId, limit]);
+
+    return rows.map(r => this.mapRow(r));
+  }
+
+  markAttributed(id, paymentId) {
+    this.db.execute(`
+      UPDATE payment_observations
+      SET attribution_status = ?, attributed_payment_id = ?
+      WHERE id = ?
+    `, [ObservationAttributionStatus.ATTRIBUTED, paymentId, id]);
+
+    return this.findById(id);
+  }
+
+  markDuplicate(id) {
+    this.db.execute(`
+      UPDATE payment_observations
+      SET attribution_status = ?
+      WHERE id = ?
+    `, [ObservationAttributionStatus.DUPLICATE_IGNORED, id]);
+
+    return this.findById(id);
+  }
+
+  markLateUnmatched(id) {
+    this.db.execute(`
+      UPDATE payment_observations
+      SET attribution_status = ?
+      WHERE id = ?
+    `, [ObservationAttributionStatus.LATE_UNMATCHED, id]);
+
+    return this.findById(id);
+  }
+
+  mapRow(row) {
+    return {
+      id: row.id,
+      receivingAccountId: row.receiving_account_id,
+      source: row.source,
+      amountPaise: BigInt(row.amount_paise),
+      observedAt: new Date(row.observed_at),
+      ingestedAt: new Date(row.ingested_at),
+      senderVpa: row.sender_vpa,
+      bankReferenceNumber: row.bank_reference_number,
+      fingerprintHash: row.fingerprint_hash,
+      rawPayload: JSON.parse(row.raw_payload || '{}'),
+      attributionStatus: row.attribution_status,
+      attributedPaymentId: row.attributed_payment_id,
+      createdAt: new Date(row.created_at)
+    };
+  }
+}