sync

connector.sync(fn)

Used to define what happens when data initially syncs from your data source into a Netlify Connect data layer, and what happens on subsequent syncs to update the data.

Takes a function with an object as a parameter. The object contains the following properties:

Parameter	Description
`models`	Object that contains all defined document models, and the `insert` and `delete` methods for each one.
`cache`	Helper for storing and accessing non-node data (like CMS sync tokens).
`isInitialSync`	Boolean that will be `true` on initial data syncs and `false` on subsequent data syncs.
`options`	Object that contains the configuration values set for options defined using `defineOptions()`.
`state`	Object that includes data stored during `init()`.
`webhookBody`	Object that contains the information sent through a webhook body.

Learn more about specifying how to create and update data.

models

Object that contains each document model you define with define.document(). Use this object to insert and delete data when there is a sync event.

Property	Description
`{model_name}`	The name of each defined document model is a property on the `models` object. Contains the `insert` and `delete` methods for each one.
`concurrent()`	Method used to fetch multiple data types from your data source concurrently.

model name

models.{model_name}

Object that represents a defined document model. The object contains the following methods:

Method	Description
`insert()`	Used to insert data for this model type. Takes an object reperesenting the data to insert.
`delete()`	Used to delete data for this model type. Takes a String value representing the node’s ID.

For example, if you define a Post document model, you can use models.Post.insert() and models.Post.delete().

Usage example

const data = {
  Post: [
    {
      id: "Post-1",
      description: "Hello world!",
      authorId: "Author-1",
      updatedAt: "2020-01-01T00:00:00.000Z",
    },
    {
      id: "Post-2",
      description: "Second post!",
      authorId: "Author-2",
      updatedAt: "2020-01-01T00:00:00.000Z",
    },
    {
      id: "Post-3",
      description: "Third post!",
      authorId: "Author-2",
      updatedAt: "2020-01-01T00:00:00.000Z",
    },
  ],
  Author: [
    {
      id: "Author-1",
      name: "Jane",
      updatedAt: "2020-01-01T00:00:00.000Z",
    },
    {
      id: "Author-2",
      name: "Marta",
      updatedAt: "2020-01-01T00:00:00.000Z",
    },
  ],
};

connector.sync(async ({ models, isInitialSync, options }) => {
  if (!isInitialSync) return; // this example only shows initial syncing logic

  for (const model of models) {
    // for each model, insert documents from the array of data for that model type
    const cmsData = data[model.name]; // note: this would usually be an API call to a CMS
    model.insert(cmsData);
  }

  /* For example, the first data item would be inserted as follows. Note
  that Netlify will add extra characters to make the id globally
  unique on insertion:

    models.Post.insert({
      id: "Post-1", // internally will be converted to a uuid
      _objectId: "Post-1", // this will stay as the original ID.
      title: "Hello world!",
    });

  */
});

concurrent

models.concurrent()

Method to fetch multiple data types from your data source concurrently.

Parameter	Description
`count`	Number of models to fetch concurrently.
`callback()`	Function to run in parallel.

Usage example

// assuming there are eight different model types defined, `concurrent` calls the function on the first four model types all at the same time.
// It then waits for the returned promises to resolve before calling the function again with a new model type each time a `concurrent` callback function resolves.

connector.sync(async ({ models }) => {
  await models.concurrent(4, async (model) => {
    const cmsNodes = await fetchCMSData(model.name);

    model.insert(cmsNodes);
  });
});

cache

Helper for storing and accessing non-node data (like CMS sync tokens). Contains the following methods:

Method	Description
`set()`	Pass in a key and value to store or update. Returns a promise.
`get()`	Pass in a key to retrieve the stored value. Returns a promise.
`delete()`	Pass in a key to delete the stored value. Returns a promise.

Learn more about the cache helper.

Usage example

const fetchCMSData = ({ since }) => {
  /* ... */
};

const makeNodesFromData = ({ cmsData, models }) => {
  for (const model of models) {
    model.insert(cmsData[model.name]);
  }
};

connector.sync(async ({ models, cache, isInitialSync }) => {
  if (isInitialSync) {
    // On initial sync, pass in a lastSync value of null to get all data
    const cmsData = await fetchCMSData({ since: null });

    makeNodesFromData({
      models,
      cmsData,
    });
  } else if (!isInitialSync) {
    // On subsequent syncs, access the lastSync value we stored
    const lastSyncTime = await cache.get("lastSync");

    // Fetch data that changed since the last time we ran a sync
    const cmsData = await fetchCMSData({
      since: lastSyncTime,
    });

    makeNodesFromData({
      models,
      cmsData,
    });
  }

  // As a final step, we update the lastSync value to now
  await cache.set("lastSync", Date.now());
});

Got it!

Your feedback helps us improve our docs.

sync

models

model name

Usage example

concurrent

Usage example

cache

Usage example

Did you find this doc useful?

Got it!