Data Synchronization Services

service: crm-contact-sync
direction: bi-directional
systems:
  - id: salesforce
    type: salesforce
    connection:
      instanceUrl: ${SALESFORCE_INSTANCE_URL}
      accessToken: ${SALESFORCE_TOKEN}
    objects:
      - name: Contact
        mapping: contacts
  - id: hubspot
    type: hubspot
    connection:
      apiKey: ${HUBSPOT_API_KEY}
    objects:
      - name: contacts
        mapping: contacts
  - id: zendesk
    type: zendesk
    connection:
      subdomain: ${ZENDESK_SUBDOMAIN}
      apiToken: ${ZENDESK_TOKEN}
    objects:
      - name: users
        mapping: contacts
syncConfig:
  frequency: realtime
  batchSize: 100
  conflictResolution: lastWriteWins
  filterConditions:
    - field: email
      operator: notNull
    - field: status
      operator: in
      values: [active, prospect]
fieldMapping:
  email: email
  firstName: first_name
  lastName: last_name
  phone: phone_number
  company: company_name
  salesforceId: external_id.salesforce
  hubspotId: external_id.hubspot
  zendeskId: external_id.zendesk

// Service automatically syncs contacts across all platforms
// When a contact is created in Salesforce:
const contact = await salesforce.create('Contact', {
  FirstName: 'Jane',
  LastName: 'Smith',
  Email: '[email protected]',
  Phone: '+14155551234',
  Company: 'Acme Corp',
})

// Service automatically:
// 1. Detects the new contact in Salesforce
// 2. Transforms the data to match HubSpot and Zendesk schemas
// 3. Creates matching contacts in HubSpot and Zendesk
// 4. Links all three records with external IDs
// 5. Begins monitoring all three for changes

// When contact is updated in any system:
await hubspot.update('contacts', hubspotId, {
  phone: '+14155559999',
})

// Service automatically:
// 1. Detects the change in HubSpot
// 2. Updates the phone number in Salesforce and Zendesk
// 3. Resolves any conflicts if phone was also changed elsewhere
// 4. Logs the sync operation
// 5. Triggers any configured webhooks

// Manual sync operations also available:
await services.sync.syncContact({
  sourceSystem: 'salesforce',
  sourceId: salesforceId,
  targetSystems: ['hubspot', 'zendesk'],
  force: true, // Sync even if no changes detected
})

// Query sync status
const status = await services.sync.getSyncStatus({
  contactId: salesforceId,
  systems: ['salesforce', 'hubspot', 'zendesk'],
})
console.log(status)
// {
//   salesforce: { lastSync: '2024-10-27T12:34:56Z', status: 'synced' },
//   hubspot: { lastSync: '2024-10-27T12:34:57Z', status: 'synced' },
//   zendesk: { lastSync: '2024-10-27T12:34:58Z', status: 'synced' }
// }

{
  "service": "inventory-sync",
  "direction": "multi-directional",
  "systems": [
    {
      "id": "warehouse-db",
      "type": "postgresql",
      "connection": {
        "host": "warehouse-db.internal",
        "database": "inventory",
        "table": "stock_levels"
      },
      "primary": true,
      "weight": 100
    },
    {
      "id": "shopify",
      "type": "shopify",
      "connection": {
        "shop": "${SHOPIFY_SHOP}",
        "accessToken": "${SHOPIFY_TOKEN}"
      },
      "weight": 50
    },
    {
      "id": "amazon",
      "type": "amazon-mws",
      "connection": {
        "sellerId": "${AMAZON_SELLER_ID}",
        "authToken": "${AMAZON_AUTH_TOKEN}"
      },
      "weight": 50
    },
    {
      "id": "ebay",
      "type": "ebay",
      "connection": {
        "userId": "${EBAY_USER_ID}",
        "token": "${EBAY_TOKEN}"
      },
      "weight": 50
    }
  ],
  "syncConfig": {
    "frequency": "realtime",
    "changeDetection": "database-trigger",
    "batchSize": 500,
    "conflictResolution": "weighted",
    "safetyThreshold": {
      "maxDecreasePercent": 50,
      "alertOnLargeChanges": true
    }
  },
  "fieldMapping": {
    "sku": "sku",
    "quantity": "inventory_quantity",
    "location": "warehouse_location",
    "reserved": "reserved_quantity",
    "available": "available_quantity"
  },
  "businessRules": [
    {
      "name": "reserve-buffer",
      "description": "Keep 5% buffer for marketplace fluctuations",
      "rule": "available = quantity - reserved - (quantity * 0.05)"
    },
    {
      "name": "low-stock-alert",
      "description": "Alert when stock falls below threshold",
      "condition": "quantity < reorderPoint",
      "action": "notify"
    }
  ]
}

// Warehouse receives new stock
await warehouseDb.query(`
  UPDATE stock_levels
  SET quantity = quantity + 100
  WHERE sku = 'WIDGET-PRO-LG'
`)

// Service automatically:
// 1. Detects the inventory change via database trigger
// 2. Calculates available quantity (applies reserve buffer)
// 3. Updates Shopify, Amazon, and eBay in parallel
// 4. Verifies all updates completed successfully
// 5. Logs the sync operation

// Order placed on Shopify
services.sync.on('order.placed', async (event) => {
  if (event.system === 'shopify') {
    // Service automatically:
    // 1. Decrements quantity in warehouse database
    // 2. Increments reserved quantity
    // 3. Updates available quantity on all marketplaces
    // 4. Checks for low stock threshold
    // 5. Sends alert if threshold crossed
  }
})

// Handle inventory conflicts
services.sync.on('conflict', async (conflict) => {
  console.log(`Conflict detected for SKU: ${conflict.sku}`)
  console.log(`Warehouse: ${conflict.warehouse.quantity}`)
  console.log(`Shopify: ${conflict.shopify.quantity}`)

  // Weighted resolution (warehouse is authoritative)
  const resolved = await services.sync.resolveConflict({
    conflictId: conflict.id,
    strategy: 'weighted',
    // Warehouse weight: 100, Marketplace weight: 50
    // Final quantity heavily favors warehouse
  })

  console.log(`Resolved to quantity: ${resolved.quantity}`)
})

// Bulk inventory sync
await services.sync.bulkSync({
  sourceSystem: 'warehouse-db',
  targetSystems: ['shopify', 'amazon', 'ebay'],
  filter: {
    updatedSince: '2024-10-26T00:00:00Z',
  },
  dryRun: false,
})

// Get sync metrics
const metrics = await services.sync.getMetrics({
  timeRange: 'last-24h',
  systems: ['warehouse-db', 'shopify', 'amazon', 'ebay'],
})
console.log(metrics)
// {
//   totalSyncs: 15234,
//   successful: 15189,
//   failed: 45,
//   conflicts: 12,
//   averageLatency: 234, // ms
//   dataVolume: 1.2 // GB
// }

service: financial-sync
direction: bi-directional
encryption: AES-256-GCM
auditLog: enabled
systems:
  - id: quickbooks
    type: quickbooks-online
    connection:
      clientId: ${QUICKBOOKS_CLIENT_ID}
      clientSecret: ${QUICKBOOKS_CLIENT_SECRET}
      realmId: ${QUICKBOOKS_REALM_ID}
    objects:
      - invoices
      - payments
      - expenses
      - accounts
  - id: stripe
    type: stripe
    connection:
      apiKey: ${STRIPE_SECRET_KEY}
    objects:
      - charges
      - refunds
      - customers
      - invoices
  - id: bank-feed
    type: plaid
    connection:
      clientId: ${PLAID_CLIENT_ID}
      secret: ${PLAID_SECRET}
      accessToken: ${PLAID_ACCESS_TOKEN}
    objects:
      - transactions
syncConfig:
  frequency: realtime
  batchSize: 50
  conflictResolution: sourceWins
  reconciliation:
    enabled: true
    schedule: daily
    tolerance: 0.01
  validation:
    checkDuplicates: true
    validateAmounts: true
    requireReceipts: true
fieldMapping:
  invoiceId: invoice_number
  amount: total_amount
  currency: currency_code
  customerId: customer_reference
  date: transaction_date
  status: payment_status
businessRules:
  - name: auto-reconcile
    condition: amounts_match && dates_match && customer_match
    action: mark_reconciled
  - name: flag-large-transactions
    condition: amount > 10000
    action: require_approval
  - name: duplicate-check
    window: 24h
    fields: [amount, customerId, date]

// Stripe payment received
await stripe.charges.create({
  amount: 9999,
  currency: 'usd',
  customer: 'cus_abc123',
  description: 'Invoice #INV-2024-001',
})

// Service automatically:
// 1. Captures the Stripe webhook
// 2. Matches to QuickBooks invoice by invoice number
// 3. Records payment in QuickBooks
// 4. Updates invoice status to "Paid"
// 5. Creates bank transaction in accounting system
// 6. Reconciles against bank feed when available

// QuickBooks invoice created
const invoice = await quickbooks.createInvoice({
  customer: 'Customer ABC',
  lineItems: [
    { description: 'Consulting Services', amount: 5000 },
    { description: 'Software License', amount: 2500 },
  ],
  dueDate: '2024-11-30',
})

// Service automatically:
// 1. Creates matching invoice in Stripe
// 2. Links QuickBooks and Stripe records
// 3. Monitors for payment in either system
// 4. Syncs payment when received

// Automatic reconciliation
services.sync.on('reconciliation', async (event) => {
  // Daily reconciliation run
  const results = await services.sync.reconcile({
    startDate: '2024-10-01',
    endDate: '2024-10-31',
    systems: ['quickbooks', 'stripe', 'bank-feed'],
  })

  console.log(`Reconciliation Results:`)
  console.log(`  Matched: ${results.matched}`)
  console.log(`  Unmatched: ${results.unmatched.length}`)
  console.log(`  Discrepancies: ${results.discrepancies.length}`)

  // Handle discrepancies
  for (const discrepancy of results.discrepancies) {
    if (Math.abs(discrepancy.difference) <= 0.01) {
      // Auto-resolve small rounding differences
      await services.sync.resolveDiscrepancy({
        id: discrepancy.id,
        resolution: 'rounding-difference',
        adjustment: discrepancy.difference,
      })
    } else {
      // Flag for manual review
      await services.sync.flagForReview({
        id: discrepancy.id,
        reason: 'amount-mismatch',
        assignTo: 'accounting-team',
      })
    }
  }
})

// Compliance reporting
const auditTrail = await services.sync.getAuditTrail({
  startDate: '2024-10-01',
  endDate: '2024-10-31',
  systems: ['quickbooks', 'stripe'],
  includeUserActions: true,
  includeSystemActions: true,
})

// Export for compliance
await services.sync.exportAudit({
  format: 'csv',
  destination: 's3://compliance-bucket/audit-trail-2024-10.csv',
})

{
  "service": "hr-data-sync",
  "direction": "bi-directional",
  "security": {
    "encryption": "AES-256",
    "pii-protection": true,
    "access-logging": true,
    "data-masking": {
      "ssn": true,
      "salary": true,
      "bank-account": true
    }
  },
  "systems": [
    {
      "id": "bamboohr",
      "type": "bamboohr",
      "connection": {
        "subdomain": "${BAMBOO_SUBDOMAIN}",
        "apiKey": "${BAMBOO_API_KEY}"
      },
      "primary": true,
      "objects": ["employees", "time-off", "benefits"]
    },
    {
      "id": "adp",
      "type": "adp-workforce",
      "connection": {
        "clientId": "${ADP_CLIENT_ID}",
        "clientSecret": "${ADP_CLIENT_SECRET}"
      },
      "objects": ["employees", "payroll", "tax"]
    },
    {
      "id": "gsuite",
      "type": "google-workspace",
      "connection": {
        "domain": "company.com",
        "serviceAccount": "${GSUITE_SERVICE_ACCOUNT}"
      },
      "objects": ["users", "groups"]
    },
    {
      "id": "okta",
      "type": "okta",
      "connection": {
        "domain": "${OKTA_DOMAIN}",
        "apiToken": "${OKTA_TOKEN}"
      },
      "objects": ["users", "groups", "apps"]
    }
  ],
  "syncConfig": {
    "frequency": "realtime",
    "batchSize": 25,
    "conflictResolution": "bamboohr-wins",
    "lifecycle": {
      "onboarding": true,
      "offboarding": true,
      "role-changes": true
    }
  },
  "fieldMapping": {
    "employeeId": "employee_number",
    "firstName": "first_name",
    "lastName": "last_name",
    "email": "work_email",
    "department": "department",
    "title": "job_title",
    "manager": "manager_id",
    "startDate": "hire_date",
    "endDate": "termination_date"
  },
  "workflows": [
    {
      "name": "employee-onboarding",
      "trigger": "new-employee",
      "steps": ["create-adp-profile", "create-gsuite-account", "create-okta-account", "assign-groups", "provision-applications", "send-welcome-email"]
    },
    {
      "name": "employee-offboarding",
      "trigger": "employee-terminated",
      "steps": ["final-payroll-adp", "suspend-gsuite-account", "deactivate-okta-account", "revoke-access", "archive-data", "notify-it-team"]
    }
  ]
}

// New employee added in BambooHR
const employee = await bamboohr.createEmployee({
  firstName: 'John',
  lastName: 'Doe',
  email: '[email protected]',
  department: 'Engineering',
  title: 'Senior Engineer',
  startDate: '2024-11-15',
  manager: 'emp_123',
})

// Service automatically triggers onboarding workflow:
// 1. Creates ADP payroll profile
// 2. Creates Google Workspace account
// 3. Creates Okta identity
// 4. Assigns to appropriate groups
// 5. Provisions SaaS application access
// 6. Sends welcome email with credentials

// Progress tracking
const onboarding = await services.sync.getWorkflowStatus({
  workflowId: 'onboarding',
  employeeId: employee.id,
})
console.log(onboarding)
// {
//   status: 'in-progress',
//   steps: [
//     { step: 'create-adp-profile', status: 'completed', timestamp: '...' },
//     { step: 'create-gsuite-account', status: 'completed', timestamp: '...' },
//     { step: 'create-okta-account', status: 'in-progress' },
//     { step: 'assign-groups', status: 'pending' },
//     ...
//   ]
// }

// Employee role change
await bamboohr.updateEmployee(employee.id, {
  title: 'Lead Engineer',
  department: 'Engineering',
  manager: 'emp_456',
})

// Service automatically:
// 1. Updates title in ADP, GSuite, Okta
// 2. Adjusts group memberships
// 3. Updates manager in all systems
// 4. Sends notifications to old and new manager
// 5. Adjusts application access if needed

// Employee termination
await bamboohr.terminateEmployee({
  employeeId: employee.id,
  terminationDate: '2024-12-31',
  reason: 'resignation',
  eligibleForRehire: true,
})

// Service automatically triggers offboarding workflow:
// 1. Schedules final payroll in ADP
// 2. Sets GSuite account to suspend on termination date
// 3. Sets Okta account to deactivate on termination date
// 4. Revokes application access
// 5. Archives employee data
// 6. Notifies IT and HR teams

// Compliance reporting
const report = await services.sync.getComplianceReport({
  type: 'employee-changes',
  startDate: '2024-10-01',
  endDate: '2024-10-31',
  includeFields: ['salary', 'role', 'access'],
  redactPii: true,
})

service: project-sync
direction: multi-directional
systems:
  - id: jira
    type: jira-cloud
    connection:
      site: ${JIRA_SITE}
      email: ${JIRA_EMAIL}
      apiToken: ${JIRA_TOKEN}
    objects:
      - issues
      - projects
      - sprints
      - time-tracking
  - id: asana
    type: asana
    connection:
      accessToken: ${ASANA_TOKEN}
    objects:
      - tasks
      - projects
      - sections
  - id: harvest
    type: harvest
    connection:
      accountId: ${HARVEST_ACCOUNT_ID}
      accessToken: ${HARVEST_TOKEN}
    objects:
      - time-entries
      - projects
      - tasks
  - id: quickbooks
    type: quickbooks-online
    connection:
      clientId: ${QUICKBOOKS_CLIENT_ID}
      clientSecret: ${QUICKBOOKS_CLIENT_SECRET}
      realmId: ${QUICKBOOKS_REALM_ID}
    objects:
      - time-activities
      - invoices
syncConfig:
  frequency: realtime
  batchSize: 100
  conflictResolution: timestamp-based
  bidirectional:
    - systems: [jira, asana]
      syncFields: [title, description, status, assignee]
    - systems: [jira, harvest]
      syncFields: [time-entries]
    - systems: [harvest, quickbooks]
      syncFields: [billable-hours]
fieldMapping:
  jira:
    issueKey: id
    summary: title
    description: description
    status: status
    assignee: assigned_to
    storyPoints: estimated_hours
  asana:
    gid: id
    name: title
    notes: description
    completed: status
    assignee: assigned_to
    custom_fields.hours: estimated_hours
  harvest:
    id: id
    notes: description
    hours: actual_hours
    billable: is_billable
    project_id: project_ref
    task_id: task_ref
businessRules:
  - name: sync-time-entries
    source: jira
    target: harvest
    condition: worklog_added
    mapping:
      issue_key: task_ref
      time_spent: hours
      comment: notes
  - name: create-invoice
    source: harvest
    target: quickbooks
    condition: project_completed
    action: generate_invoice

// Jira issue created
const issue = await jira.createIssue({
  project: 'PROJ',
  summary: 'Implement user authentication',
  description: 'Add OAuth 2.0 authentication flow',
  issueType: 'Story',
  storyPoints: 8,
  assignee: 'john.doe',
})

// Service automatically:
// 1. Creates matching task in Asana
// 2. Creates project/task in Harvest for time tracking
// 3. Links all three records
// 4. Begins monitoring for changes

// Time logged in Jira
await jira.addWorklog({
  issueKey: issue.key,
  timeSpent: '2h',
  comment: 'Implemented OAuth flow',
})

// Service automatically:
// 1. Creates time entry in Harvest
// 2. Marks as billable based on project settings
// 3. Links to correct project and task

// Task completed in Asana
await asana.updateTask(asanaTaskId, {
  completed: true,
})

// Service automatically:
// 1. Transitions Jira issue to "Done"
// 2. Calculates total time from Harvest
// 3. Generates invoice in QuickBooks if project is billable
// 4. Sends notification to project stakeholders

// Bi-directional sync example
await jira.updateIssue(issue.key, {
  assignee: 'jane.smith',
})

// Service automatically:
// 1. Updates assignee in Asana task
// 2. Future time entries in Harvest associate with Jane
// 3. Notification sent to Jane in all systems

// Billing workflow
services.sync.on('project.completed', async (event) => {
  // Aggregate time entries
  const timeEntries = await services.sync.getTimeEntries({
    projectId: event.projectId,
    systems: ['jira', 'harvest'],
    billable: true,
  })

  const totalHours = timeEntries.reduce((sum, entry) => sum + entry.hours, 0)
  const hourlyRate = event.project.hourlyRate

  // Create invoice in QuickBooks
  await quickbooks.createInvoice({
    customer: event.project.customer,
    lineItems: timeEntries.map((entry) => ({
      description: `${entry.task}: ${entry.description}`,
      quantity: entry.hours,
      rate: hourlyRate,
      amount: entry.hours * hourlyRate,
    })),
    dueDate: addDays(new Date(), 30),
  })
})

// Sync analytics
const analytics = await services.sync.getAnalytics({
  timeRange: 'last-30-days',
  groupBy: 'project',
  metrics: ['time-logged', 'tasks-completed', 'revenue-generated'],
})

{
  "service": "cdp-sync",
  "direction": "multi-directional",
  "systems": [
    {
      "id": "segment",
      "type": "segment",
      "connection": {
        "writeKey": "${SEGMENT_WRITE_KEY}",
        "space": "${SEGMENT_SPACE}"
      },
      "primary": true,
      "objects": ["users", "events", "traits"]
    },
    {
      "id": "salesforce",
      "type": "salesforce",
      "objects": ["contacts", "leads", "accounts"]
    },
    {
      "id": "hubspot",
      "type": "hubspot",
      "objects": ["contacts", "companies", "deals"]
    },
    {
      "id": "intercom",
      "type": "intercom",
      "objects": ["users", "companies", "conversations"]
    },
    {
      "id": "klaviyo",
      "type": "klaviyo",
      "objects": ["profiles", "lists"]
    }
  ],
  "syncConfig": {
    "frequency": "realtime",
    "enrichment": {
      "enabled": true,
      "sources": ["clearbit", "fullcontact"],
      "onNewContact": true
    },
    "deduplication": {
      "enabled": true,
      "matchFields": ["email", "phone"],
      "mergeStrategy": "most-complete"
    },
    "gdpr": {
      "enabled": true,
      "rightToErasure": true,
      "dataPortability": true,
      "consentTracking": true
    }
  },
  "unifiedSchema": {
    "userId": "id",
    "email": "email",
    "firstName": "first_name",
    "lastName": "last_name",
    "company": "company_name",
    "lifecycleStage": "lifecycle_stage",
    "ltv": "lifetime_value",
    "lastSeen": "last_active_at",
    "traits": "custom_properties"
  }
}

// User signs up on website (tracked by Segment)
analytics.identify('user_123', {
  email: '[email protected]',
  firstName: 'New',
  lastName: 'User',
  company: 'Example Corp',
  plan: 'trial',
})

// Service automatically:
// 1. Enriches profile with Clearbit data (company size, industry, etc.)
// 2. Creates contact in Salesforce (as Lead)
// 3. Creates contact in HubSpot
// 4. Creates user in Intercom
// 5. Creates profile in Klaviyo
// 6. Links all records with unified ID

// User activity tracked in any system syncs everywhere
await intercom.trackEvent('user_123', 'feature_used', {
  feature: 'advanced_analytics',
  timestamp: new Date(),
})

// Service automatically:
// 1. Sends event to Segment
// 2. Updates last_seen in all systems
// 3. Triggers lifecycle stage progression if applicable
// 4. Updates engagement score

// Sales rep updates in Salesforce
await salesforce.updateContact(contactId, {
  Status: 'Qualified',
  LeadSource: 'Website',
  Phone: '+14155551234',
})

// Service automatically:
// 1. Updates contact in all other systems
// 2. Triggers marketing automation in HubSpot
// 3. Updates Intercom for support team visibility
// 4. Adds to appropriate Klaviyo segments

// GDPR data erasure request
await services.sync.eraseUserData({
  userId: 'user_123',
  systems: 'all',
  retentionOverride: {
    system: 'salesforce',
    reason: 'legal-hold',
    expirationDate: '2025-01-01',
  },
})

// Service automatically:
// 1. Anonymizes user data in Segment
// 2. Deletes contact from HubSpot
// 3. Deletes user from Intercom
// 4. Deletes profile from Klaviyo
// 5. Marks for deletion in Salesforce (with hold)
// 6. Generates compliance report

// Unified customer view
const customer = await services.sync.getUnifiedProfile('user_123')
console.log(customer)
// {
//   id: 'user_123',
//   email: '[email protected]',
//   firstName: 'New',
//   lastName: 'User',
//   company: {
//     name: 'Example Corp',
//     size: '50-100',
//     industry: 'Technology'
//   },
//   lifecycleStage: 'customer',
//   ltv: 4999,
//   enrichment: {
//     title: 'Engineering Manager',
//     linkedin: 'https://linkedin.com/in/...'
//   },
//   activity: {
//     lastSeen: '2024-10-27T14:30:00Z',
//     totalEvents: 1234,
//     topFeatures: ['advanced_analytics', 'reporting']
//   },
//   systemIds: {
//     segment: 'user_123',
//     salesforce: 'con_abc',
//     hubspot: '12345',
//     intercom: 'int_xyz',
//     klaviyo: 'klv_789'
//   }
// }

Tier 1 (0 - 100K syncs/month):       $0.005 per sync = $500
Tier 2 (100K - 1M syncs/month):      $0.003 per sync = $2,700
Tier 3 (1M - 10M syncs/month):       $0.001 per sync = $9,000
Tier 4 (10M+ syncs/month):           $0.0005 per sync
Real-time sync: +$0.002 per sync
Complex transformations: +$0.001 per sync

Contacts:
- 0 - 10K records:        $0.10 per record/month = $1,000
- 10K - 100K records:     $0.05 per record/month = $5,000
- 100K - 1M records:      $0.01 per record/month = $10,000
- 1M+ records:            $0.005 per record/month

Products/Inventory:
- 0 - 1K SKUs:            $1.00 per SKU/month = $1,000
- 1K - 10K SKUs:          $0.50 per SKU/month = $5,000
- 10K+ SKUs:              $0.25 per SKU/month

Transactions:
- $0.01 per transaction
- Minimum: $100/month

Standard Integrations:
- $199/month per integration
- Includes 100K syncs/month
- Overage: $0.002 per sync

Premium Integrations (SAP, Oracle, etc.):
- $999/month per integration
- Includes 500K syncs/month
- Overage: $0.001 per sync

Bi-directional Premium:
- 2x standard pricing
- Advanced conflict resolution included

Starter:
- $500/month base
- 3 integrations included
- 500K syncs/month included
- 50K records under management
- Additional integrations: $100/month
- Overage: $0.003 per sync

Professional:
- $2,000/month base
- 10 integrations included
- 5M syncs/month included
- 500K records under management
- Additional integrations: $50/month
- Overage: $0.001 per sync

Enterprise:
- $10,000/month base
- Unlimited integrations
- 50M syncs/month included
- 5M records under management
- Custom SLA and support
- Overage: $0.0005 per sync

Real-time Sync:                   +50% base price
Advanced Conflict Resolution:     +$500/month
Data Enrichment:                  +$0.01 per record
Custom Transformations:           +$1,000/month
Dedicated Support:                +$2,000/month
99.99% SLA:                       +$1,500/month
HIPAA/SOC2 Compliance:            +$3,000/month
White-label:                      +$5,000/month

// Use optimistic locking
const update = await services.sync.update({
  system: 'salesforce',
  recordId: contactId,
  version: currentVersion, // Will fail if version changed
  data: updates,
})

// Use conditional updates
const update = await services.sync.update({
  system: 'database',
  recordId: userId,
  conditions: {
    status: 'active', // Only update if status is active
    lastModified: { lt: '2024-10-27T00:00:00Z' },
  },
  data: updates,
})

// Monitor sync lag
services.sync.on('lag', (event) => {
  if (event.lagSeconds > 300) {
    // 5 minutes
    alerting.send({
      severity: 'warning',
      message: `Sync lag for ${event.system}: ${event.lagSeconds}s`,
    })
  }
})

// Track sync failures
services.sync.on('failure', async (event) => {
  if (event.consecutiveFailures > 3) {
    await alerting.send({
      severity: 'critical',
      message: `Sync failing for ${event.system}: ${event.error}`,
    })

    // Automatic remediation
    await services.sync.resetConnection(event.system)
  }
})

// Performance metrics
const metrics = await services.sync.getMetrics({
  interval: '1h',
  systems: ['all'],
})

// Validation rules
const config = {
  validation: {
    email: {
      required: true,
      format: 'email',
    },
    phone: {
      format: 'E.164',
      normalize: true,
    },
    amount: {
      type: 'number',
      min: 0,
      precision: 2,
    },
  },

  // Data cleansing
  cleansing: {
    trimWhitespace: true,
    normalizeCase: {
      email: 'lowercase',
      name: 'titlecase',
    },
    removeInvalidChars: true,
  },

  // Deduplication
  deduplication: {
    matchFields: ['email'],
    fuzzyMatch: {
      name: { threshold: 0.9 },
    },
    mergeStrategy: 'most-recent-with-most-fields',
  },
}