How to Build a Integration Hub with Replit

1// Prompt to type into Replit Agent:
2// Build an integration hub with Express and PostgreSQL using Drizzle ORM.
3// Create these tables in shared/schema.ts:
4// - connections: id serial pk, user_id text not null, service_name text not null,
5//   credentials_encrypted text not null, status text default 'active', created_at timestamp
6// - integrations: id serial pk, user_id text not null, name text not null,
7//   source_connection_id integer references connections,
8//   destination_connection_id integer references connections,
9//   transform_config jsonb (field mapping rules), is_active boolean default true,
10//   created_at timestamp
11// - integration_runs: id serial pk, integration_id integer references integrations not null,
12//   status text not null (running/success/failed),
13//   records_processed integer default 0, error_message text,
14//   started_at timestamp default now(), completed_at timestamp
15// - webhook_endpoints: id serial pk, integration_id integer references integrations not null,
16//   path text unique not null, secret text not null, created_at timestamp
17// Create a server/lib/crypto.js module with:
18//   encrypt(plaintext): uses Node.js crypto.createCipheriv with AES-256-GCM
19//     returns: {iv, authTag, ciphertext} encoded as a single string
20//   decrypt(encrypted): reverses the above
21// The encryption key comes from process.env.ENCRYPTION_KEY (32 bytes, stored in Secrets)
22// Set up Replit Auth. Bind server to 0.0.0.0.

1const { encrypt, decrypt } = require('../lib/crypto');
2const { db } = require('../db');
3const { connections, integrations } = require('../../shared/schema');
4const { eq, and } = require('drizzle-orm');
5
6// POST /api/connections — store encrypted credentials
7router.post('/api/connections', async (req, res) => {
8  if (!req.user) return res.status(401).json({ error: 'Auth required' });
9  const { serviceName, credentials } = req.body;
10
11  if (!credentials || typeof credentials !== 'object') {
12    return res.status(400).json({ error: 'credentials must be an object' });
13  }
14
15  const credentialsEncrypted = encrypt(JSON.stringify(credentials));
16
17  const [conn] = await db.insert(connections).values({
18    userId: req.user.id,
19    serviceName,
20    credentialsEncrypted
21  }).returning();
22
23  // Never return the encrypted credentials in the response
24  res.json({ id: conn.id, serviceName: conn.serviceName, status: conn.status, createdAt: conn.createdAt });
25});
26
27// GET /api/connections — list without credentials
28router.get('/api/connections', async (req, res) => {
29  if (!req.user) return res.status(401).json({ error: 'Auth required' });
30  const conns = await db.select({
31    id: connections.id,
32    serviceName: connections.serviceName,
33    status: connections.status,
34    createdAt: connections.createdAt
35  }).from(connections).where(eq(connections.userId, req.user.id));
36  res.json(conns);
37});
38
39// POST /api/integrations — create integration with transform config
40router.post('/api/integrations', async (req, res) => {
41  if (!req.user) return res.status(401).json({ error: 'Auth required' });
42  const { name, sourceConnectionId, destinationConnectionId, transformConfig } = req.body;
43
44  // Verify both connections belong to user
45  const [src, dst] = await Promise.all([
46    db.query.connections.findFirst({ where: and(eq(connections.id, Number(sourceConnectionId)), eq(connections.userId, req.user.id)) }),
47    db.query.connections.findFirst({ where: and(eq(connections.id, Number(destinationConnectionId)), eq(connections.userId, req.user.id)) })
48  ]);
49  if (!src || !dst) return res.status(404).json({ error: 'Connection not found' });
50
51  const [integration] = await db.insert(integrations).values({
52    userId: req.user.id, name, sourceConnectionId: src.id,
53    destinationConnectionId: dst.id, transformConfig
54  }).returning();
55
56  res.json(integration);
57});

1const crypto = require('crypto');
2const { decrypt } = require('../lib/crypto');
3const { db } = require('../db');
4const { webhookEndpoints, integrations, connections, integrationRuns } = require('../../shared/schema');
5const { eq } = require('drizzle-orm');
6
7// Dynamic webhook receiver
8router.post('/api/webhooks/:path', async (req, res) => {
9  const { path } = req.params;
10
11  const endpoint = await db.query.webhookEndpoints.findFirst({
12    where: eq(webhookEndpoints.path, path)
13  });
14
15  if (!endpoint) return res.status(404).json({ error: 'Webhook endpoint not found' });
16
17  // Verify HMAC signature
18  const signature = req.headers['x-hub-signature-256'] || req.headers['x-signature'];
19  if (signature) {
20    const expectedSig = 'sha256=' + crypto.createHmac('sha256', endpoint.secret)
21      .update(JSON.stringify(req.body)).digest('hex');
22    if (signature !== expectedSig) {
23      return res.status(401).json({ error: 'Invalid signature' });
24    }
25  }
26
27  // Acknowledge immediately — process async
28  res.json({ received: true });
29
30  // Execute integration asynchronously
31  executeIntegration(endpoint.integrationId, req.body).catch(err => {
32    console.error('Integration execution error:', err.message);
33  });
34});
35
36async function executeIntegration(integrationId, triggerData) {
37  const [run] = await db.insert(integrationRuns).values({
38    integrationId, status: 'running'
39  }).returning();
40
41  try {
42    const integration = await db.query.integrations.findFirst({
43      where: eq(integrations.id, integrationId)
44    });
45
46    const srcConn = await db.query.connections.findFirst({ where: eq(connections.id, integration.sourceConnectionId) });
47    const dstConn = await db.query.connections.findFirst({ where: eq(connections.id, integration.destinationConnectionId) });
48
49    const srcCredentials = JSON.parse(decrypt(srcConn.credentialsEncrypted));
50    const dstCredentials = JSON.parse(decrypt(dstConn.credentialsEncrypted));
51
52    // Apply field transformation
53    const transformedData = applyTransform(triggerData, integration.transformConfig);
54
55    // Execute destination call
56    const response = await fetch(dstCredentials.webhookUrl || dstCredentials.apiEndpoint, {
57      method: 'POST',
58      headers: { 'Content-Type': 'application/json',
59        ...(dstCredentials.apiKey ? { 'Authorization': `Bearer ${dstCredentials.apiKey}` } : {}) },
60      body: JSON.stringify(transformedData)
61    });
62
63    if (!response.ok) throw new Error(`Destination responded with ${response.status}`);
64
65    await db.update(integrationRuns).set({
66      status: 'success', recordsProcessed: 1, completedAt: new Date()
67    }).where(eq(integrationRuns.id, run.id));
68
69  } catch (err) {
70    await db.update(integrationRuns).set({
71      status: 'failed', errorMessage: err.message, completedAt: new Date()
72    }).where(eq(integrationRuns.id, run.id));
73  }
74}
75
76function applyTransform(data, config) {
77  if (!config || !config.fieldMappings) return data;
78  const result = {};
79  for (const mapping of config.fieldMappings) {
80    const value = mapping.sourceField.split('.').reduce((obj, key) => obj?.[key], data);
81    if (value !== undefined) {
82      result[mapping.destinationField] = mapping.transform ? applyFieldTransform(value, mapping.transform) : value;
83    }
84  }
85  return result;
86}
87
88function applyFieldTransform(value, transform) {
89  if (transform === 'uppercase') return String(value).toUpperCase();
90  if (transform === 'lowercase') return String(value).toLowerCase();
91  if (transform === 'toString') return String(value);
92  if (transform === 'toNumber') return Number(value);
93  return value;
94}

1// Prompt to type into Replit Agent:
2// Add these routes to server/routes/integrations.js:
3//
4// POST /api/integrations/:id/webhook — create webhook endpoint for an integration
5//   Auto-generate a unique path: crypto.randomBytes(8).toString('hex')
6//   Auto-generate a webhook secret: crypto.randomBytes(16).toString('hex')
7//   INSERT INTO webhook_endpoints (integration_id, path, secret)
8//   Return: {path, secret, fullUrl: `${process.env.APP_URL}/api/webhooks/${path}`}
9//
10// POST /api/integrations/:id/test — dry-run with sample data
11//   Body: {sampleData: {...}}
12//   Load the integration's transform_config
13//   Apply applyTransform(sampleData, transformConfig)
14//   Return: {input: sampleData, output: transformedData, mappingsApplied: count}
15//   Does NOT call any external APIs — just shows the transformation result
16//
17// GET /api/integrations/:id/runs — execution history
18//   Return last 50 runs ordered by started_at DESC
19//   Include: status, records_processed, error_message, started_at, completed_at,
20//   duration_ms (completed_at - started_at in milliseconds)
21//
22// PATCH /api/integrations/:id/toggle — enable/disable integration
23//   Toggle is_active boolean
24//   Return {isActive: newValue}
25//
26// GET /api/integrations/:id/runs/:runId — single run detail
27//   Return full run details including any error_message

1// Prompt to type into Replit Agent:
2// Build the React frontend at client/src/pages/:
3//
4// 1. ConnectionsPage:
5//    - List of existing connections showing service name, status badge, created date
6//    - 'Add Connection' button opens a modal:
7//      Service name input, JSON credentials editor (textarea with format hint),
8//      Submit → POST /api/connections
9//    - Delete connection button (if no active integrations use it)
10//
11// 2. IntegrationsPage:
12//    - List of integrations: name, source service → destination service, active/inactive badge
13//    - 'New Integration' button opens a wizard:
14//      Step 1: Select source connection, destination connection
15//      Step 2: Build field mapping rules (add row: source field → destination field, optional transform)
16//      Step 3: Name the integration, create webhook endpoint
17//      Show the webhook URL to copy into the source service
18//    - Toggle active/inactive switch per integration
19//    - Test button → calls /api/integrations/:id/test with sample JSON
20//
21// 3. RunsPage for each integration:
22//    - Data table: started_at, status (success/failed with colors), records_processed,
23//      duration, error_message (truncated with expand button)
24//    - Refresh every 30 seconds
25//
26// Then deploy:
27// 1. Add ENCRYPTION_KEY, SESSION_SECRET, APP_URL to Replit Secrets
28// 2. Ensure server binds to 0.0.0.0
29// 3. Deploy → Reserved VM (NOT Autoscale — webhook receiver must be always-on)