How to Integrate Replit with Wave

1// check-wave-secrets.js
2const required = ['WAVE_CLIENT_ID', 'WAVE_CLIENT_SECRET', 'WAVE_ACCESS_TOKEN', 'WAVE_REDIRECT_URI'];
3for (const key of required) {
4  if (!process.env[key]) {
5    throw new Error(`Missing secret: ${key}. Set it in Replit Secrets (lock icon 🔒).`);
6  }
7}
8console.log('Wave secrets verified.');
9console.log('Client ID:', process.env.WAVE_CLIENT_ID);

1// wave.js — Wave Accounting GraphQL API for Node.js on Replit
2const axios = require('axios');
3const express = require('express');
4
5const app = express();
6app.use(express.json());
7
8const WAVE_GQL = 'https://gql.waveapps.com/graphql/public';
9const TOKEN = process.env.WAVE_ACCESS_TOKEN;
10
11async function waveQuery(query, variables = {}) {
12  const response = await axios.post(
13    WAVE_GQL,
14    { query, variables },
15    { headers: { 'Authorization': `Bearer ${TOKEN}`, 'Content-Type': 'application/json' } }
16  );
17  if (response.data.errors) {
18    throw new Error(JSON.stringify(response.data.errors));
19  }
20  return response.data.data;
21}
22
23// Get all businesses on the account
24app.get('/api/businesses', async (req, res) => {
25  try {
26    const data = await waveQuery(`
27      query GetBusinesses {
28        businesses {
29          edges {
30            node {
31              id
32              name
33              currency { code symbol }
34              isPersonal
35            }
36          }
37        }
38      }
39    `);
40    const businesses = data.businesses.edges.map(e => e.node);
41    res.json({ businesses });
42  } catch (err) {
43    res.status(500).json({ error: err.message });
44  }
45});
46
47// Get customers for a business
48app.get('/api/customers/:businessId', async (req, res) => {
49  try {
50    const data = await waveQuery(`
51      query GetCustomers($businessId: ID!) {
52        business(id: $businessId) {
53          customers {
54            edges {
55              node {
56                id
57                name
58                email
59                mobile
60              }
61            }
62          }
63        }
64      }
65    `, { businessId: req.params.businessId });
66    
67    const customers = data.business.customers.edges.map(e => e.node);
68    res.json({ customers });
69  } catch (err) {
70    res.status(500).json({ error: err.message });
71  }
72});
73
74// Create an invoice
75app.post('/api/invoices', async (req, res) => {
76  const { businessId, customerId, invoiceDate, dueDate, items, memo } = req.body;
77  try {
78    const data = await waveQuery(`
79      mutation CreateInvoice($input: InvoiceCreateInput!) {
80        invoiceCreate(input: $input) {
81          didSucceed
82          inputErrors { code message path }
83          invoice {
84            id
85            invoiceNumber
86            status
87            amountDue { value currency { code } }
88            pdfUrl
89          }
90        }
91      }
92    `, {
93      input: {
94        businessId,
95        customerId,
96        invoiceDate,
97        dueDate,
98        memo: memo || '',
99        items: items.map(item => ({
100          productId: item.productId,
101          description: item.description,
102          quantity: item.quantity,
103          unitPrice: item.unitPrice
104        }))
105      }
106    });
107    
108    const result = data.invoiceCreate;
109    if (!result.didSucceed) {
110      return res.status(400).json({ errors: result.inputErrors });
111    }
112    res.json({ success: true, invoice: result.invoice });
113  } catch (err) {
114    res.status(500).json({ error: err.message });
115  }
116});
117
118app.listen(3000, '0.0.0.0', () => console.log('Wave API server running on port 3000'));

1# wave_api.py — Wave Accounting GraphQL API for Python on Replit
2import os
3import requests
4from flask import Flask, request, jsonify
5
6WAVE_GQL = 'https://gql.waveapps.com/graphql/public'
7TOKEN = os.environ['WAVE_ACCESS_TOKEN']
8
9session = requests.Session()
10session.headers.update({'Authorization': f'Bearer {TOKEN}', 'Content-Type': 'application/json'})
11
12app = Flask(__name__)
13
14def wave_query(query: str, variables: dict = None) -> dict:
15    """Execute a Wave GraphQL query or mutation."""
16    response = session.post(WAVE_GQL, json={'query': query, 'variables': variables or {}})
17    response.raise_for_status()
18    data = response.json()
19    if 'errors' in data:
20        raise ValueError(f"GraphQL errors: {data['errors']}")
21    return data['data']
22
23@app.route('/api/businesses')
24def get_businesses():
25    try:
26        data = wave_query('''
27            query { businesses { edges { node { id name currency { code } } } } }
28        ''')
29        businesses = [e['node'] for e in data['businesses']['edges']]
30        return jsonify({'businesses': businesses})
31    except Exception as e:
32        return jsonify({'error': str(e)}), 500
33
34@app.route('/api/invoices')
35def get_invoices():
36    business_id = request.args.get('businessId')
37    if not business_id:
38        return jsonify({'error': 'businessId required'}), 400
39    try:
40        data = wave_query('''
41            query GetInvoices($businessId: ID!) {
42                business(id: $businessId) {
43                    invoices {
44                        edges {
45                            node {
46                                id invoiceNumber status
47                                invoiceDate dueDate
48                                amountDue { value }
49                                customer { id name email }
50                            }
51                        }
52                    }
53                }
54            }
55        ''', {'businessId': business_id})
56        invoices = [e['node'] for e in data['business']['invoices']['edges']]
57        return jsonify({'invoices': invoices, 'count': len(invoices)})
58    except Exception as e:
59        return jsonify({'error': str(e)}), 500
60
61@app.route('/api/customers', methods=['POST'])
62def create_customer():
63    payload = request.get_json()
64    try:
65        data = wave_query('''
66            mutation CreateCustomer($input: CustomerCreateInput!) {
67                customerCreate(input: $input) {
68                    didSucceed
69                    inputErrors { code message }
70                    customer { id name email }
71                }
72            }
73        ''', {'input': {
74            'businessId': payload['businessId'],
75            'name': payload['name'],
76            'email': payload.get('email', '')
77        }})
78        result = data['customerCreate']
79        if not result['didSucceed']:
80            return jsonify({'errors': result['inputErrors']}), 400
81        return jsonify({'success': True, 'customer': result['customer']})
82    except Exception as e:
83        return jsonify({'error': str(e)}), 500
84
85if __name__ == '__main__':
86    app.run(host='0.0.0.0', port=3000)