Implement a sync

import { createSync } from 'nango';
import * as z from 'zod';

const MyObject = z.object({
  id: z.string(),
  first_name: z.string(),
  last_name: z.string(),
  email: z.string(),
});

export default createSync({
    description: `<Description of your sync>`,
    version: '1.0.0', // Version, increment it when you release a new version
    endpoints: [{ method: 'GET', path: '/<integration>/<object-name>', group: '<Group>' }],
    frequency: 'every hour', // Default sync interval
    autoStart: true, // Should the sync start immediately when a new connection is created?
    trackDeletes: true, // detect deletes? See separate implementation guide
    // Optional: define a checkpoint schema to save progress and avoid re-fetching all data
    checkpoint: z.object({
        lastModifiedISO: z.string(),
    }),
    models: {
        MyObject: MyObject,
    },
    exec: async (nango) => {
        // Integration code goes here.
    },
});

import { createSync } from 'nango';
import * as z from 'zod';

const SalesforceContact = z.object({
  id: z.string(),
  first_name: z.string(),
  last_name: z.string(),
  email: z.string(),
  account_id: z.string().nullable(),
  last_modified_date: z.string(),
});

export default createSync({
  description: `Fetches contacts from Salesforce`,
  version: '1.0.0',
  endpoints: [{ method: 'GET', path: '/salesforce/contacts', group: 'Contacts' }],
  frequency: 'every hour',
  autoStart: true,
  // Define checkpoint schema to track sync progress
  checkpoint: z.object({
    lastModifiedISO: z.string(),
  }),
  models: {
    SalesforceContact: SalesforceContact,
  },
  exec: async (nango) => {
    // Get checkpoint to resume from where we left off
    const checkpoint = await nango.getCheckpoint();
    const query = buildQuery(checkpoint?.lastModifiedISO);

    await fetchAndSaveRecords(nango, query);

    await nango.log('Sync run completed!');
  },
});
export type NangoSyncLocal = Parameters<(typeof sync)['exec']>[0];

function buildQuery(lastModifiedISO?: string): string {
    let baseQuery = `SELECT Id, FirstName, LastName, Email, AccountId, LastModifiedDate FROM Contact`;

    if (lastModifiedISO) { // Only fetch data modified since last sync
        baseQuery += ` WHERE LastModifiedDate > ${lastModifiedISO}`;
    }
    baseQuery += ` ORDER BY LastModifiedDate ASC`;

    return baseQuery;
}

async function fetchAndSaveRecords(nango: NangoSyncLocal, query: string) {
    let endpoint = '/services/data/v53.0/query';

    while (true) {
        const response = await nango.get({
            endpoint: endpoint,
            params: endpoint === '/services/data/v53.0/query' ? { q: query } : {}
        });

        const mappedRecords = mapContacts(response.data.records);

        await nango.batchSave(mappedRecords, 'SalesforceContact'); // Saves records to Nango cache.

        // Save checkpoint for next run
        await nango.saveCheckpoint({ lastModifiedISO: mappedRecords[mappedRecords.length - 1].last_modified_date });

        if (response.data.done) {
            break;
        }

        endpoint = response.data.nextRecordsUrl;
    }
}

function mapContacts(records: any[]): SalesforceContact[] {
    return records.map((record: any) => {
        return {
            id: record.Id as string,
            first_name: record.FirstName,
            last_name: record.LastName,
            email: record.Email,
            account_id: record.AccountId,
            last_modified_date: record.LastModifiedDate
        };
    });
}