xero.js

Go to the documentation of this file.

// Xero Backend Plugin: Sync invoices and customers via Redis events
const Redis = require('ioredis');
const pool = require('../services/db');
const redisConfig = require('../config/redis');
const redis = new Redis(redisConfig);
 
// Query integrations table for Xero config for a tenant
/**
 *
 * @param tenantId
 */
async function getXeroConfigForTenant(tenantId) {
  const result = await pool.query(
    `SELECT config FROM integrations WHERE tenant_id = $1 AND integration_type = 'xero' AND is_active = true LIMIT 1`,
    [tenantId]
  );
  return result.rows.length ? result.rows[0].config : null;
}
 
const { XeroClient } = require('xero-node');
 
/**
 *
 * @param config
 */
function createXeroClient(config) {
  return new XeroClient({
    clientId: config.client_id,
    clientSecret: config.client_secret,
    redirectUris: ['http://localhost'], // adjust as needed
    scopes: 'openid profile email accounting.transactions accounting.contacts'.split(' '),
  });
}
 
/**
 *
 * @param invoice
 * @param config
 */
async function syncInvoiceToXero(invoice, config) {
  const xero = createXeroClient(config);
  // You must have a valid access token and tenantId in config
  await xero.setTokenSet({ access_token: config.access_token, id_token: '', expires_at: 0 });
  xero.tenantIds = [config.xero_tenant_id];
 
  // Map your invoice to Xero format
  const xeroInvoice = {
    Type: 'ACCREC',
    Contact: { ContactID: invoice.customer_id }, // map to Xero contact
    LineItems: invoice.items.map(item => ({
      Description: item.description,
      Quantity: item.quantity,
      UnitAmount: item.unit_price,
      AccountCode: '200', // adjust as needed
    })),
    Date: invoice.issued_date,
    DueDate: invoice.due_date,
    Status: 'AUTHORISED',
    LineAmountTypes: 'Exclusive',
  };
 
  try {
    const result = await xero.accountingApi.createInvoices(config.xero_tenant_id, { Invoices: [xeroInvoice] });
    console.log('[Xero] Invoice synced:', result.body.Invoices[0].InvoiceID);
  } catch (err) {
    console.error('[Xero] Invoice sync error:', err);
  }
}
 
/**
 *
 * @param customer
 * @param config
 */
async function syncCustomerToXero(customer, config) {
  const xero = createXeroClient(config);
  await xero.setTokenSet({ access_token: config.access_token, id_token: '', expires_at: 0 });
  xero.tenantIds = [config.xero_tenant_id];
 
  const xeroContact = {
    Name: customer.name,
    EmailAddress: customer.email,
    Phones: [{ PhoneType: 'DEFAULT', PhoneNumber: customer.phone }],
    Addresses: [{ AddressType: 'STREET', AddressLine1: customer.address, City: customer.city, PostalCode: customer.postal_code, Country: customer.country }],
  };
 
  try {
    const result = await xero.accountingApi.createContacts(config.xero_tenant_id, { Contacts: [xeroContact] });
    console.log('[Xero] Customer synced:', result.body.Contacts[0].ContactID);
  } catch (err) {
    console.error('[Xero] Customer sync error:', err);
  }
}
 
redis.subscribe('events', (err, count) => {
  if (err) console.error('[Xero] Redis subscribe error:', err);
  else console.log('[Xero] Subscribed to events channel');
});
 
redis.on('message', async (channel, message) => {
  if (channel !== 'events') return;
  const event = JSON.parse(message);
 
  if (['invoice.created', 'customer.created'].includes(event.type)) {
    const { tenant_id, data } = event;
    const xeroConfig = await getXeroConfigForTenant(tenant_id);
    if (xeroConfig) {
      if (event.type === 'invoice.created') {
        await syncInvoiceToXero(data, xeroConfig);
      } else if (event.type === 'customer.created') {
        await syncCustomerToXero(data, xeroConfig);
      }
    } else {
      console.log(`[Xero] Skipping event for tenant ${tenant_id} (Xero not enabled)`);
    }
  }
});
 
// --- Scaffold: Manual fetch endpoints and audit logging ---
const express = require('express');
const xeroRouter = express.Router();
 
// GET /api/xero/invoices/:tenant_id - Fetch invoices from Xero for tenant
xeroRouter.get('/invoices/:tenant_id', async (req, res) => {
  const { tenant_id } = req.params;
  try {
    const xeroConfig = await getXeroConfigForTenant(tenant_id);
    if (!xeroConfig) return res.status(404).json({ error: 'Xero not configured for tenant' });
    const xero = createXeroClient(xeroConfig);
    await xero.setTokenSet({ access_token: xeroConfig.access_token, id_token: '', expires_at: 0 });
    xero.tenantIds = [xeroConfig.xero_tenant_id];
    const result = await xero.accountingApi.getInvoices(xeroConfig.xero_tenant_id);
    // Audit log
    await pool.query('INSERT INTO audit_log (tenant_id, action, details) VALUES ($1, $2, $3)', [tenant_id, 'xero.fetch.invoices', JSON.stringify({ count: result.body.Invoices.length })]);
    res.json({ invoices: result.body.Invoices });
  } catch (err) {
    res.status(500).json({ error: 'Failed to fetch invoices', details: err.message });
  }
});
 
// GET /api/xero/contacts/:tenant_id - Fetch contacts from Xero for tenant
xeroRouter.get('/contacts/:tenant_id', async (req, res) => {
  const { tenant_id } = req.params;
  try {
    const xeroConfig = await getXeroConfigForTenant(tenant_id);
    if (!xeroConfig) return res.status(404).json({ error: 'Xero not configured for tenant' });
    const xero = createXeroClient(xeroConfig);
    await xero.setTokenSet({ access_token: xeroConfig.access_token, id_token: '', expires_at: 0 });
    xero.tenantIds = [xeroConfig.xero_tenant_id];
    const result = await xero.accountingApi.getContacts(xeroConfig.xero_tenant_id);
    // Audit log
    await pool.query('INSERT INTO audit_log (tenant_id, action, details) VALUES ($1, $2, $3)', [tenant_id, 'xero.fetch.contacts', JSON.stringify({ count: result.body.Contacts.length })]);
    res.json({ contacts: result.body.Contacts });
  } catch (err) {
    res.status(500).json({ error: 'Failed to fetch contacts', details: err.message });
  }
});
 
module.exports = { getXeroConfigForTenant, createXeroClient, syncInvoiceToXero, syncCustomerToXero, xeroRouter };