How to Integrate Replit with Microsoft Dynamics 365

1// check-dynamics-secrets.js
2const required = [
3  'AZURE_TENANT_ID',
4  'AZURE_CLIENT_ID',
5  'AZURE_CLIENT_SECRET',
6  'DYNAMICS_URL'
7];
8for (const key of required) {
9  if (!process.env[key]) {
10    throw new Error(`Missing: ${key}. Add it in Replit Secrets (lock icon 🔒).`);
11  }
12}
13// Validate GUID format for tenant and client IDs
14const GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
15if (!GUID_REGEX.test(process.env.AZURE_TENANT_ID)) {
16  throw new Error('AZURE_TENANT_ID must be a GUID (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)');
17}
18if (!GUID_REGEX.test(process.env.AZURE_CLIENT_ID)) {
19  throw new Error('AZURE_CLIENT_ID must be a GUID (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)');
20}
21if (!process.env.DYNAMICS_URL.startsWith('https://')) {
22  throw new Error('DYNAMICS_URL must start with https://');
23}
24console.log('Dynamics 365 secrets validated.');
25console.log('Tenant:', process.env.AZURE_TENANT_ID);
26console.log('Dynamics URL:', process.env.DYNAMICS_URL);

1// dynamics-auth.js — Azure AD client credentials token management
2const TOKEN_CACHE = { token: null, expiresAt: 0 };
3
4async function getAccessToken() {
5  // Return cached token if still valid (with 60s buffer)
6  if (TOKEN_CACHE.token && Date.now() < TOKEN_CACHE.expiresAt - 60000) {
7    return TOKEN_CACHE.token;
8  }
9
10  const tenantId = process.env.AZURE_TENANT_ID;
11  const clientId = process.env.AZURE_CLIENT_ID;
12  const clientSecret = process.env.AZURE_CLIENT_SECRET;
13  const dynamicsUrl = process.env.DYNAMICS_URL;
14
15  const tokenUrl = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0/token`;
16
17  const body = new URLSearchParams({
18    grant_type: 'client_credentials',
19    client_id: clientId,
20    client_secret: clientSecret,
21    scope: `${dynamicsUrl}/.default`  // e.g. https://yourorg.crm.dynamics.com/.default
22  });
23
24  const response = await fetch(tokenUrl, {
25    method: 'POST',
26    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
27    body: body.toString()
28  });
29
30  if (!response.ok) {
31    const err = await response.json();
32    throw new Error(`Azure AD token error: ${err.error} — ${err.error_description}`);
33  }
34
35  const data = await response.json();
36  TOKEN_CACHE.token = data.access_token;
37  TOKEN_CACHE.expiresAt = Date.now() + data.expires_in * 1000;
38
39  console.log(`Access token obtained. Expires in ${data.expires_in}s.`);
40  return TOKEN_CACHE.token;
41}
42
43async function dynamicsRequest(method, path, body = null) {
44  const token = await getAccessToken();
45  const dynamicsUrl = process.env.DYNAMICS_URL;
46
47  const options = {
48    method,
49    headers: {
50      'Authorization': `Bearer ${token}`,
51      'Content-Type': 'application/json',
52      'Accept': 'application/json',
53      'OData-MaxVersion': '4.0',
54      'OData-Version': '4.0',
55      'Prefer': 'odata.include-annotations="*"' // Include display names and option labels
56    }
57  };
58  if (body) options.body = JSON.stringify(body);
59
60  const url = `${dynamicsUrl}/api/data/v9.2/${path}`;
61  const response = await fetch(url, options);
62
63  if (!response.ok) {
64    const errText = await response.text();
65    throw new Error(`Dynamics API ${response.status}: ${errText}`);
66  }
67  if (response.status === 204) return null;
68  return response.json();
69}
70
71module.exports = { getAccessToken, dynamicsRequest };

1// dynamics-entities.js — Query and create Dynamics 365 entities
2const { dynamicsRequest } = require('./dynamics-auth');
3
4// --- CONTACTS ---
5
6// Get contacts with OData filtering and field selection
7async function getContacts(filter = '', top = 50) {
8  const params = new URLSearchParams({
9    '$select': 'fullname,emailaddress1,telephone1,jobtitle,_parentaccountid_value',
10    '$top': top.toString(),
11    '$orderby': 'createdon desc'
12  });
13  if (filter) params.set('$filter', filter);
14
15  const result = await dynamicsRequest('GET', `contacts?${params}`);
16  return result?.value || [];
17}
18
19// Get contacts for a specific account
20async function getContactsByAccount(accountId) {
21  const filter = `_parentaccountid_value eq '${accountId}'`;
22  return getContacts(filter);
23}
24
25// Create a new Contact
26async function createContact(data) {
27  // Dynamics returns 204 with OData-EntityId header — use Prefer: return=representation to get body
28  const response = await fetch(
29    `${process.env.DYNAMICS_URL}/api/data/v9.2/contacts`,
30    {
31      method: 'POST',
32      headers: {
33        'Authorization': `Bearer ${await require('./dynamics-auth').getAccessToken()}`,
34        'Content-Type': 'application/json',
35        'OData-MaxVersion': '4.0',
36        'OData-Version': '4.0',
37        'Prefer': 'return=representation'  // Return the created record
38      },
39      body: JSON.stringify(data)
40    }
41  );
42  if (response.status === 201) return response.json();
43  if (response.status === 204) {
44    const entityId = response.headers.get('OData-EntityId');
45    const guid = entityId?.match(/\(([^)]+)\)/)?.[1];
46    return { contactid: guid };
47  }
48  throw new Error(`Create contact failed: ${response.status}`);
49}
50
51// --- LEADS ---
52
53async function createLead(firstName, lastName, email, company, phone) {
54  return dynamicsRequest('POST', 'leads', {
55    firstname: firstName,
56    lastname: lastName,
57    emailaddress1: email,
58    companyname: company,
59    mobilephone: phone,
60    subject: `New Lead: ${firstName} ${lastName}`
61  });
62}
63
64// --- OPPORTUNITIES ---
65
66async function getOpenOpportunities() {
67  const params = new URLSearchParams({
68    '$select': 'name,estimatedvalue,closedate,statecode,_ownerid_value',
69    '$filter': 'statecode eq 0',  // 0 = Open
70    '$expand': '_parentaccountid_value($select=name)',
71    '$orderby': 'closedate asc',
72    '$top': '100'
73  });
74  const result = await dynamicsRequest('GET', `opportunities?${params}`);
75  return result?.value || [];
76}
77
78// Update an entity by ID
79async function updateEntity(entitySet, id, updates) {
80  return dynamicsRequest('PATCH', `${entitySet}(${id})`, updates);
81}
82
83// Example
84(async () => {
85  const contacts = await getContacts('emailaddress1 ne null', 10);
86  console.log(`Found ${contacts.length} contacts`);
87  contacts.forEach(c => console.log(` - ${c.fullname} <${c.emailaddress1}>`))
88
89  const opps = await getOpenOpportunities();
90  console.log(`\nOpen opportunities: ${opps.length}`);
91})();

1# dynamics_client.py — Dynamics 365 Web API client with Python
2import os
3import requests
4from msal import ConfidentialClientApplication
5
6# MSAL handles token caching and refresh automatically
7_msal_app = None
8
9def get_msal_app():
10    global _msal_app
11    if _msal_app is None:
12        _msal_app = ConfidentialClientApplication(
13            client_id=os.environ['AZURE_CLIENT_ID'],
14            client_credential=os.environ['AZURE_CLIENT_SECRET'],
15            authority=f'https://login.microsoftonline.com/{os.environ["AZURE_TENANT_ID"]}'
16        )
17    return _msal_app
18
19def get_access_token() -> str:
20    """Get a valid access token for Dynamics 365 (cached by MSAL)."""
21    dynamics_url = os.environ['DYNAMICS_URL']
22    scopes = [f'{dynamics_url}/.default']
23    app = get_msal_app()
24
25    # Try to get token from cache first
26    result = app.acquire_token_silent(scopes, account=None)
27    if not result:
28        result = app.acquire_token_for_client(scopes)
29
30    if 'error' in result:
31        raise Exception(f'Token error: {result["error"]} — {result.get("error_description")}')
32
33    return result['access_token']
34
35def dynamics_request(method: str, path: str, body: dict = None, params: dict = None) -> dict:
36    """Make an authenticated Dynamics 365 Web API request."""
37    token = get_access_token()
38    base_url = os.environ['DYNAMICS_URL']
39    url = f'{base_url}/api/data/v9.2/{path}'
40
41    headers = {
42        'Authorization': f'Bearer {token}',
43        'Content-Type': 'application/json',
44        'Accept': 'application/json',
45        'OData-MaxVersion': '4.0',
46        'OData-Version': '4.0'
47    }
48
49    response = requests.request(method, url, headers=headers, json=body, params=params)
50
51    if not response.ok:
52        raise Exception(f'Dynamics API {response.status_code}: {response.text}')
53    if response.status_code == 204:
54        return {'entity_id': response.headers.get('OData-EntityId', '')}
55    return response.json()
56
57def get_accounts(top: int = 50) -> list:
58    """Get top N accounts from Dynamics 365."""
59    result = dynamics_request('GET', 'accounts', params={
60        '$select': 'name,emailaddress1,telephone1,revenue',
61        '$top': str(top),
62        '$filter': 'statecode eq 0',
63        '$orderby': 'name asc'
64    })
65    return result.get('value', [])
66
67def create_lead(first_name: str, last_name: str, email: str, company: str) -> dict:
68    """Create a new Lead in Dynamics 365."""
69    return dynamics_request('POST', 'leads', body={
70        'firstname': first_name,
71        'lastname': last_name,
72        'emailaddress1': email,
73        'companyname': company,
74        'subject': f'New Lead: {first_name} {last_name}'
75    })
76
77if __name__ == '__main__':
78    accounts = get_accounts(5)
79    print(f'Found {len(accounts)} accounts:')
80    for a in accounts:
81        print(f'  - {a["name"]}')
82
83    lead = create_lead('John', 'Doe', 'john@example.com', 'Acme Corp')
84    print(f'Created lead: {lead}')

1// dynamics-pagination.js — Handle large result sets with OData pagination
2const { dynamicsRequest } = require('./dynamics-auth');
3
4// Fetch ALL records matching a query (handles pagination automatically)
5async function fetchAll(entitySet, queryParams) {
6  let results = [];
7  let nextLink = null;
8
9  // Build initial URL
10  const params = new URLSearchParams(queryParams);
11  let path = `${entitySet}?${params}`;
12
13  do {
14    const response = await dynamicsRequest('GET', path);
15    const records = response?.value || [];
16    results = results.concat(records);
17
18    // Check for next page
19    nextLink = response?.['@odata.nextLink'];
20    if (nextLink) {
21      // nextLink is an absolute URL — extract the path+query part
22      const url = new URL(nextLink);
23      path = url.pathname.replace('/api/data/v9.2/', '') + url.search;
24      console.log(`Fetching next page... (${results.length} records so far)`);
25    }
26  } while (nextLink);
27
28  console.log(`Total records fetched: ${results.length}`);
29  return results;
30}
31
32// Batch operations — create multiple records efficiently
33async function batchCreateLeads(leads) {
34  // Dynamics $batch endpoint allows up to 1000 operations in one request
35  const results = [];
36  for (const lead of leads) {
37    try {
38      const result = await dynamicsRequest('POST', 'leads', lead);
39      results.push({ success: true, lead: lead.emailaddress1, result });
40    } catch (err) {
41      console.error(`Failed to create lead ${lead.emailaddress1}:`, err.message);
42      results.push({ success: false, lead: lead.emailaddress1, error: err.message });
43    }
44  }
45  return results;
46}
47
48// Express server exposing Dynamics data
49const express = require('express');
50const app = express();
51app.use(express.json());
52
53app.get('/api/leads', async (req, res) => {
54  try {
55    const { filter, top = '50' } = req.query;
56    const params = {
57      '$select': 'firstname,lastname,emailaddress1,companyname,statuscode',
58      '$top': top,
59      '$orderby': 'createdon desc'
60    };
61    if (filter) params['$filter'] = filter;
62    const leads = await dynamicsRequest('GET', `leads?${new URLSearchParams(params)}`);
63    res.json(leads?.value || []);
64  } catch (err) {
65    console.error('Dynamics error:', err.message);
66    res.status(500).json({ error: err.message });
67  }
68});
69
70app.post('/api/leads', async (req, res) => {
71  try {
72    const result = await dynamicsRequest('POST', 'leads', req.body);
73    res.status(201).json(result);
74  } catch (err) {
75    res.status(500).json({ error: err.message });
76  }
77});
78
79app.listen(3000, '0.0.0.0', () => console.log('Dynamics proxy API running on port 3000'));