$fh.sync.setConfig(options)

$fh.events.on('sync:ready', function(){
  var pendingWorkerInterval = process.env.PENDING_WORKER_INTERVAL || 500;
  var syncWorkerInterval = process.env.SYNC_WORKER_INTERVAL || 500;
  var ackWorkerInterval = process.env.ACK_WORKER_INTERVAL || 500;
  var useCache = process.env.USE_CACHE === 'true';
  var syncConfig = {
    pendingWorkerInterval: parseInt(pendingWorkerInterval),
    ackWorkerInterval: parseInt(ackWorkerInterval),
    syncWorkerInterval: parseInt(syncWorkerInterval),
    collectStatsInterval: 4000,
    metricsInfluxdbHost: process.env.METRICS_HOST,
    metricsInfluxdbPort: parseInt(process.env.METRICS_PORT),
    useCache: useCache
  };
  $fh.sync.setConfig(syncConfig);
});

$fh.sync.connect(mongodbConnectionString, mongodbConf, redisConnectionString, callback)

var mongodbUrl = "mongodb://mongouser:mongopass@127.0.0.1";
var redisUrl = "redis://redisuser:redispass@127.0.0.1";

$fh.sync.connect(mongodbUrl, {}, redisUrl, function(err){
  if (err) {
    console.error('Connection error for sync', err);
  } else {
    console.log('sync connected');
  }
});

$fh.sync.init(dataset_id, options, callback)

var datasetId = "todolist";
var syncOptions = {
  syncFrequency: 10,
  clientSyncTimeout: 24*60*60
};
$fh.sync.init(datasetId, syncOptions, function(err){
  if (err) {
    console.error('sync init failed due to error', err);
  } else {
    console.log('sync init finished successfully');
  }
});

$fh.sync.init(dataset_id, options, callback)

指定されたデータセットのクラウドデータ同期サービスを初期化します。

// Unique Id for the dataset to initialise.
var dataset_id = 'tasks';
// Configuration options
var options = {
  "syncFrequency": 10, // How often to synchronise data with the back end data store in seconds. Default: 10s
  "logLevel":"info" // The level of logging. Can be usful for debugging. Valid options including: 'silly', 'verbose', 'info', 'warn', 'debug', 'error'
};
$fh.sync.init(dataset_id, options, function(err) {
  // Check for any error thrown during initialisation
  if (err) {
    console.error(err);
  } else {
    //you can now provide data handler function overrides (again, not required at all). For example,
    $fh.sync.handleList(dataset_id, function(dataset_id, params, cb, meta_data){
      //implement the data listing logic
    });
  }
});

$fh.sync.invoke(dataset_id, params, callback)

var datasetId = "todo";
var syncRecordsParams = {
  fn: 'syncRecords',
  dataset_id: datasetId,
  query_params: {},
  clientRecs: {},
  __fh: {
    cuid: 'testdeviceid'
  }
};

$fh.sync.invoke(datasetId, syncRecordsParams, function(err, syncData) {
  if (err) {
    console.error('Failed to call syncRecords due to error', err);
  } else {
    console.log('Got sync data', syncData);
  }
});

$fh.sync.invoke(dataset_id, params, callback)

同期サーバーを起動します。

// This should be called from a cloud “act” function.
// The params passed to the “act” function:
var params = {
  "limit": 50
};
$fh.sync.invoke(dataset_id, params, function() {
  // "act" function callback
});

$fh.sync.stop(dataset_id, callback)

var datasetId = "todolist";
$fh.sync.stop(datasetId, function(err){
  if (err) {
    console.error('sync stop failed due to error', err);
  } else {
    console.log('sync stop finished successfully');
  }
});

$fh.sync.stop(dataset_id, callback)

指定された dataset_id のクラウドデータ同期を停止します。

// This will remove any reference to the dataset from the sync service.
// Any subsequent cloud calls to sync.invoke will fail with an unknown_dataset error.
// The dataset can be put back under control of the sync service by calling the
// sync.init() function again.
// Calling stop on a non-existent dataset has no effect.
// Calling stop multiple times on the same dataset has no effect.
$fh.sync.stop(dataset_id, function() {
  // Callback to invoke once the dataset has been removed from the management
  // of the service.
  // There are no parameters passed to this callback.
});

$fh.sync.stopAll(callback)

$fh.sync.stopAll(function(err){
  if (err) {
    console.error('sync stopAll failed due to error', err);
  } else {
    console.log('sync stopAll finished successfully');
  }
});

$fh.sync.stopAll(callback)

全データセットのクラウドデータ同期サービスを停止します。

// This will remove all reference to all datasets from the sync service.
// Any subsequent cloud calls to sync.invoke() will fail with an unknown_dataset error.
// Any of the datasets can be put back under control of the sync service by calling
// the sync.init() function again and passing the required dataset_id.
// Calling stop multiple times has no effect -
// except that the return data to the callback (an array of dataset_ids which are no longer being synced) will be different.
$fh.sync.stopAll(function(err, res) {
  if (err) console.error(err); // Any error thrown during the removal of the datasets

  // A JSON Array of Strings - representing the dataset_Ids which have been
  // removed from the sync service.
  console.log(res);
});

$fh.sync.handleList(dataset_id, function listHandler(dataset_id, query_params, meta_data, cb){});

$fh.sync.handleList("todo", function(dataset_id, params, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // JSON object representing query parameters passed from the client.
  // These can be used to restrict the data set returned.
  console.log(params);

  // The callback into the sync service to store the dataset
  // cb(err, data)
  cb(null, { // A JSON Object - representing the data
    uid_1 : {/* data */},
    uid_2 : {/* data */},
    uid_3 : {/* data */}
  });
});

// It is recommended that the handleList function converts data from the back end
// format into a full JSON Object.
// This is a sensible approach when reading data from relational and nonrelational
// databases, and works well for SOAP and XML data.
// However, it may not always be feasible - for example, when reading non structured data.
// In these cases, the recomened approach is to create a JSON object with a single
// key called “data” and set the value for this key to be the actual data.
// for example, xml data
/*
<dataset>
  <row>
    <userid>123456</userid>
    <firstname>Joe</firstname>
    <surname>Bloggs</surname>
    <dob>1970-01-01</dob>
    <gender>male</gender>
  </row>
</dataset>
*/
/* json data
{
  "123456" : {
    "userid" : "123456",
    "firstname" : "Joe",
    "surname" : "Bloggs",
    "dob" : "1970-01-01",
    "gender" : "male"
  }
}
*/

// And for non structured data:
/*
123456|Joe|Bloggs|1970-01-01|male

{
  "123456" : {
    "data" : "123456|Joe|Bloggs|1970-01-01|male"
  }
}
*/

$fh.sync.handleList(dataset_id, callback)

データセットのデータをバックエンドデータソースから一覧表示するハンドラー関数を定義します。データセットが初期化された後にこの API を呼び出してください。

$fh.sync.handleList(dataset_id, function(dataset_id, params, cb, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // JSON object representing query parameters passed from the client.
  // These can be used to restrict the data set returned.
  console.log(params);

  // The callback into the sync service to store the dataset
  // cb(err, data)
  cb(null, { // A JSON Object - representing the data
    uid_1 : {/* data */},
    uid_2 : {/* data */},
    uid_3 : {/* data */}
  });
});
// It is recommended that the handleList function converts data from the back end
// format into a full JSON Object.
// This is a sensible approach when reading data from relational and nonrelational
// databases, and works well for SOAP and XML data.
// However, it may not always be feasible - for example, when reading non structured data.
// In these cases, the recomened approach is to create a JSON object with a single
// key called “data” and set the value for this key to be the actual data.
// for example, xml data
/*
<dataset>
  <row>
    <userid>123456</userid>
    <firstname>Joe</firstname>
    <surname>Bloggs</surname>
    <dob>1970-01-01</dob>
    <gender>male</gender>
  </row>
</dataset>
*/
/* json data
{
  "123456" : {
    "userid" : "123456",
    "firstname" : "Joe",
    "surname" : "Bloggs",
    "dob" : "1970-01-01",
    "gender" : "male"
  }
}
*/

// And for non structured data:
/*
123456|Joe|Bloggs|1970-01-01|male

{
  "123456" : {
    "data" : "123456|Joe|Bloggs|1970-01-01|male"
  }
}
*/

$fh.sync.globalHandleList(function listHandler(dataset_id, query_params, meta_data, cb){});

$fh.sync.globalHandleList(function(dataset_id, params, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // JSON object representing query parameters passed from the client.
  // These can be used to restrict the data set returned.
  console.log(params);

  // The callback into the sync service to store the dataset
  // cb(err, data)
  cb(null, { // A JSON Object - representing the data
    uid_1 : {/* data */},
    uid_2 : {/* data */},
    uid_3 : {/* data */}
  });
});

// It is recommended that the handleList function converts data from the back end
// format into a full JSON Object.
// This is a sensible approach when reading data from relational and nonrelational
// databases, and works well for SOAP and XML data.
// However, it may not always be feasible - for example, when reading non structured data.
// In these cases, the recomened approach is to create a JSON object with a single
// key called “data” and set the value for this key to be the actual data.
// for example, xml data
/*
<dataset>
  <row>
    <userid>123456</userid>
    <firstname>Joe</firstname>
    <surname>Bloggs</surname>
    <dob>1970-01-01</dob>
    <gender>male</gender>
  </row>
</dataset>
*/
/* json data
{
  "123456" : {
    "userid" : "123456",
    "firstname" : "Joe",
    "surname" : "Bloggs",
    "dob" : "1970-01-01",
    "gender" : "male"
  }
}
*/

// And for non structured data:
/*
123456|Joe|Bloggs|1970-01-01|male

{
  "123456" : {
    "data" : "123456|Joe|Bloggs|1970-01-01|male"
  }
}
*/

$fh.sync.globalHandleList(callback)

$fh.sync.handleList と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.handleList でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalHandleList(function(dataset_id, params, cb, meta_data){
  //list data for the specified dataset_id
});

$fh.sync.handleCreate(dataset_id, function createHandler(dataset_id, data, meta_data, cb){});

$fh.sync.handleCreate("todo", function(dataset_id, data, meta_data, cb){
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Row of data to create
  console.log(data);

  // Sample back-end storage call
  var savedData = saveData(data);
  var res = {
    "uid": savedData.uid, // Unique Identifier for row
    "data": savedData.data // The created data record - including any system or UID fields added during the create process
  };

  // Callback function for when the data has been created, or if theres an error
  return cb(null, res);
});

$fh.sync.handleCreate(dataset_id, callback)

バックエンドで単一行のデータを作成するハンドラー関数を定義します。データセットが初期化された後に呼び出してください。

// data source for a dataset.
$fh.sync.handleCreate(dataset_id, function(dataset_id, data, cb, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Row of data to create
  console.log(data);

  // Sample back-end storage call
  var savedData = saveData(data);
  var res = {
    "uid": savedData.uid, // Unique Identifier for row
    "data": savedData.data // The created data record - including any system or UID fields added during the create process
  };

  // Callback function for when the data has been created, or if theres an error
  return cb(null, res);
});

$fh.sync.globalHandleCreate(function createHandler(dataset_id, data, meta_data, cb){});

$fh.sync.globalHandleCreate(function(dataset_id, data, meta_data, cb){
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Row of data to create
  console.log(data);

  // Sample back-end storage call
  var savedData = saveData(data);
  var res = {
    "uid": savedData.uid, // Unique Identifier for row
    "data": savedData.data // The created data record - including any system or UID fields added during the create process
  };

  // Callback function for when the data has been created, or if theres an error
  return cb(null, res);
});

$fh.sync.globalHandleCreate(callback)

$fh.sync.handleCreate と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.handleCreate でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalHandleCreate(function(dataset_id, data, cb, meta_data){
  //create data for the specified dataset_id
});

$fh.sync.handleRead(dataset_id, function readHandler(dataset_id, uid, meta_data, cb){});

$fh.sync.handleRead("todo", function(dataset_id, uid, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to read
  console.log(uid);

  // Sample back-end storage call
  var data = readData(uid);
  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the row of data
  return cb(null, data);
});

$fh.sync.handleRead(dataset_id, callback)

バックエンドから単一行のデータを読み取るハンドラー関数を定義します。データセットが初期化された後に呼び出してください。

// data source for a dataset
$fh.sync.handleRead(dataset_id, function(dataset_id, uid, cb, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to read
  console.log(uid);

  // Sample back-end storage call
  var data = readData(uid);
  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the row of data
  return cb(null, data);
});

$fh.sync.globalHandleRead(function readHandler(dataset_id, uid, meta_data, cb){});

$fh.sync.globalHandleRead(function(dataset_id, uid, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to read
  console.log(uid);

  // Sample back-end storage call
  var data = readData(uid);
  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the row of data
  return cb(null, data);
});

$fh.sync.globalHandleRead(callback)

$fh.sync.handleRead と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.handleRead でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalHandleRead(function(dataset_id, uid, cb, meta_data){
  //read data for the specified dataset_id and uid
});

$fh.sync.handleUpdate(dataset_id, function updateHandler(dataset_id, uid, data, meta_data, cb){});

$fh.sync.handleUpdate("todo", function(dataset_id, uid, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to update
  console.log(uid);

  // Row of data to update
  console.log(data);

  // Sample back-end storage call
  var updatedData = updateData(uid, data);
  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the updated row of data
  return cb(null, updatedData);
});

$fh.sync.handleUpdate(dataset_id, callback)

バックエンドから単一行のデータを更新するハンドラー関数を定義します。データセットが初期化された後に呼び出してください。

// data source for a dataset.
// The sync service will verify that the update can proceed
// (that is, collision detection) before it invokes the update function.
$fh.sync.handleUpdate(dataset_id, function(dataset_id, uid, data, cb, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to update
  console.log(uid);

  // Row of data to update
  console.log(data);

  // Sample back-end storage call
  var updatedData = updateData(uid, data);
  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the updated row of data
  return cb(null, updatedData);
});

$fh.sync.globalHandleUpdate(function updateHandler(dataset_id, uid, data, meta_data, cb){});

$fh.sync.globalHandleUpdate(function(dataset_id, uid, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to update
  console.log(uid);

  // Row of data to update
  console.log(data);

  // Sample back-end storage call
  var updatedData = updateData(uid, data);
  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the updated row of data
  return cb(null, updatedData);
});

$fh.sync.globalHandleUpdate(callback)

$fh.sync.handleUpdate と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.handleUpdate でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalHandleUpdate(function(dataset_id, uid, data, cb, meta_data){
  //update data for the specified dataset_id and uid
});

$fh.sync.handleDelete(dataset_id, function deleteHandler(dataset_id, uid, meta_data, cb){});

$fh.sync.handleDelete("todo", function(dataset_id, uid, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to update
  console.log(uid);

  // Sample back-end storage call
  var deletedData = deleteData(uid);

  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the deleted row of data
  return cb(null, deletedData);
});

$fh.sync.handleDelete(dataset_id, callback)

バックエンドから単一行のデータを削除するハンドラー関数を定義します。データセットが初期化された後に呼び出してください。

// data source for a dataset.
// The sync service will verify that the delete can proceed
// (that is, collision detection) before it invokes the delete function.
$fh.sync.handleDelete(dataset_id, function(dataset_id, uid, cb, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to update
  console.log(uid);

  // Sample back-end storage call
  var deletedData = deleteData(uid);

  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the deleted row of data
  return cb(null, deletedData);
});

$fh.sync.globalHandleDelete(function deleteHandler(dataset_id, uid, meta_data, cb){});

$fh.sync.globalHandleDelete(function(dataset_id, uid, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique Identifier for row to update
  console.log(uid);

  // Sample back-end storage call
  var deletedData = deleteData(uid);

  /* sample response
    {
      "userid": "1234",
      "name": "Jane Bloggs",
      "age": 27
    }
  */

  // The callback into the sync service to return the deleted row of data
  return cb(null, deletedData);
});

$fh.sync.globalHandleDelete(callback)

$fh.sync.handleDelete と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.handleDelete でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalHandleDelete(function(dataset_id, uid, cb, meta_data){
  //delete data for the specified dataset_id and uid
});

$fh.sync.handleCollision(dataset_id, function collisionHandler(dataset_id, hash, timestamp, uid, pre, post, meta_data){});

// Typically a collision handler will write the data record to a collisions table
// which is reviewed by a user who can manually reconcile the collisions.
$fh.sync.handleCollision("todo", function(dataset_id, hash, timestamp, uid, pre, post, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique hash value identifying the collision
  console.log(hash);

  // Date / time that update was created on client device
  console.log(timestamp);

  // Unique Identifier for row
  console.log(uid);

  // The data row the client started with
  console.log(pre);

  //The data row the client tried to write
  console.log(post);

  // sample back-end storage call
  saveCollisionData(dataset_id, hash, timestamp, uid, pre, post);
});

$fh.sync.handleCollision(dataset_id, callback)

データ競合 (古い更新) に対処するハンドラー関数を定義します。データセットが初期化された後に呼び出してください。

// Typically a collision handler will write the data record to a collisions table
// which is reviewed by a user who can manually reconcile the collisions.
$fh.sync.handleCollision(dataset_id, function(dataset_id, hash, timestamp, uid, pre, post, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique hash value identifying the collision
  console.log(hash);

  // Date / time that update was created on client device
  console.log(timestamp);

  // Unique Identifier for row
  console.log(uid);

  // The data row the client started with
  console.log(pre);

  //The data row the client tried to write
  console.log(post);

  // sample back-end storage call
  saveCollisionData(dataset_id, hash, timestamp, uid, pre, post);
});

$fh.sync.globalHandleCollision(function collisionHandler(dataset_id, hash, timestamp, uid, pre, post, meta_data){});

// Typically a collision handler will write the data record to a collisions table
// which is reviewed by a user who can manually reconcile the collisions.
$fh.sync.globalHandleCollision(function(dataset_id, hash, timestamp, uid, pre, post, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // Unique hash value identifying the collision
  console.log(hash);

  // Date / time that update was created on client device
  console.log(timestamp);

  // Unique Identifier for row
  console.log(uid);

  // The data row the client started with
  console.log(pre);

  //The data row the client tried to write
  console.log(post);

  // sample back-end storage call
  saveCollisionData(dataset_id, hash, timestamp, uid, pre, post);
});

$fh.sync.globalHandleCollision(callback)

$fh.sync.handleCollision と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.handleCollision でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalHandleCollision(function(dataset_id, hash, timestamp, uid, pre, post, meta_data){

});

$fh.sync.listCollisions(dataset_id, function listCollisionsHandler(dataset_id, meta_data, cb){});

// This would usually be used by an administration console where a user is
// manually reviewing & resolving collisions.
$fh.sync.listCollisions("todo", function(dataset_id, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // sample back-end storage call
  var collisions = getCollisions(dataset_id);
  /* sample response:
  {
    "collision_hash_1" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    },
    "collision_hash_2" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    },
    "collision_hash_2" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    }
  }
  */

  // The callback into the sync service to return the list of known collisions
  return cb(null, collisions);
});

$fh.sync.listCollisions(dataset_id, callback)

競合の現在の一覧を返すハンドラー関数を定義します。データセットが初期化された後に呼び出してください。

// This would usually be used by an administration console where a user is
// manually reviewing & resolving collisions.
$fh.sync.listCollisions(dataset_id, function(dataset_id, cb, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // sample back-end storage call
  var collisions = getCollisions(dataset_id);
  /* sample response:
  {
    "collision_hash_1" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    },
    "collision_hash_2" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    },
    "collision_hash_2" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    }
  }
  */

  // The callback into the sync service to return the list of known collisions
  return cb(null, collisions);
});

$fh.sync.globalListCollisions(function listCollisionsHandler(dataset_id, meta_data, cb){});

// This would usually be used by an administration console where a user is
// manually reviewing & resolving collisions.
$fh.sync.globalListCollisions(function(dataset_id, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // sample back-end storage call
  var collisions = getCollisions(dataset_id);
  /* sample response:
  {
    "collision_hash_1" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    },
    "collision_hash_2" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    },
    "collision_hash_2" : {
      "uid": "<uid_of_data_row>",
      "timestamp": "<timestamp_value_passed_to_handleCollision_fn>",
      "pre": "<pre_data_record_passed_to_handleCollision_fn>",
      "post": "<post_data_record_passed_to_handleCollision_fn>"
    }
  }
  */

  // The callback into the sync service to return the list of known collisions
  return cb(null, collisions);
});

$fh.sync.globalListCollisions(callback)

$fh.sync.listCollisions と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.listCollisions でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalListCollisions(function(dataset_id, cb, meta_data){

});

$fh.sync.removeCollision(dataset_id, function removeCollisionHandler(dataset_id, collision_hash, meta_data, cb){});

// This would usually be used by an administration console where a user is
// manually reviewing & resolving collisions.
$fh.sync.removeCollision("todo", function(dataset_id, collision_hash, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // sample back-end storage call
  removeCollision(collision_hash);

  // The callback into the sync service to return the delete row of data
  return cb(null);
});

$fh.sync.removeCollision(dataset_id, callback)

競合一覧からある競合を削除するハンドラー関数を定義します。データセットが初期化された後に呼び出してください。

// This would usually be used by an administration console where a user is
// manually reviewing & resolving collisions.
$fh.sync.removeCollision(dataset_id, function(dataset_id, collision_hash, cb, meta_data) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // sample back-end storage call
  removeCollision(collision_hash);

  // The callback into the sync service to return the delete row of data
  return cb(null);
});

$fh.sync.globalRemoveCollision(function removeCollisionHandler(dataset_id, collision_hash, meta_data, cb){});

// This would usually be used by an administration console where a user is
// manually reviewing & resolving collisions.
$fh.sync.globalRemoveCollision(function(dataset_id, collision_hash, meta_data, cb) {
  // The dataset identifier that this function was defined for
  console.log(dataset_id);

  // sample back-end storage call
  removeCollision(collision_hash);

  // The callback into the sync service to return the delete row of data
  return cb(null);
});

$fh.sync.globalRemoveCollision(callback)

$fh.sync.removeCollision と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.removeCollision でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalRemoveCollision(function(dataset_id, collision_hash, cb, meta_data){

});

$fh.sync.interceptRequest(dataset_id, function requestInterceptor(dataset_id, interceptorParams, cb){});

$fh.sync.interceptRequest("todo", function(dataset_id, interceptorParams, cb){

  var query_params = interceptorParams.query_params; //the query_params specified in the client $fh.sync.manage
  var meta_data = interceptorParams.meta_data;  //the meta_data specified in the client $fh.sync.manage

  var validUser = function(qp, meta){
    //implement user authentication and return true or false
  };

  if(validUser(query_params, meta_data)){
    return cb(null);
  } else {
     // Return a non null response to cause the sync request to fail.
    return cb({error: 'invalid user'});
  }
});

$fh.sync.interceptRequest(dataset_id, callback);

指定されたデータセットの同期リクエストをインターセプトします。クライアント ID のチェックや認証の検証に便利です。

$fh.sync.interceptRequest(dataset_id, function(dataset_id, interceptorParams, cb){

  var query_params = interceptorParams.query_params; //the query_params specified in the client $fh.sync.manage
  var meta_data = interceptorParams.meta_data;  //the meta_data specified in the client $fh.sync.manage

  var validUser = function(qp, meta){
    //implement user authentication and return true or false
  };

  if(validUser(query_params, meta_data)){
    return cb(null);
  } else {
     // Return a non null response to cause the sync request to fail.
    return cb({error: 'invalid user'});
  }
});

$fh.sync.setRecordHashFn(dataset_id, function generateHash(dataset_id, record){});

レコードのハッシュ値。

$fh.sync.setRecordHashFn("todo", function(dataset_id, record){
  return record.lastModified;
});

$fh.sync.setGlobalHashFn(dataset_id, function generateHash(dataRecordHashes){});

データセットのグローバルハッシュ値。

$fh.sync.setGlobalHashFn("todo", function(dataRecordHashes){
  return dataRecordHashes.join('');
});

$fh.sync.globalInterceptRequest(function requestInterceptor(dataset_id, interceptorParams, cb){});

$fh.sync.globalInterceptRequest(function(dataset_id, interceptorParams, cb){

  var query_params = interceptorParams.query_params; //the query_params specified in the client $fh.sync.manage
  var meta_data = interceptorParams.meta_data;  //the meta_data specified in the client $fh.sync.manage

  var validUser = function(qp, meta){
    //implement user authentication and return true or false
  };

  if(validUser(query_params, meta_data)){
    return cb(null);
  } else {
     // Return a non null response to cause the sync request to fail.
    return cb({error: 'invalid user'});
  }
});

$fh.sync.globalInterceptRequest(callback)

$fh.sync.interceptRequest と似ていますが、ハンドラーをグローバルに設定することで複数のデータセットが同一のハンドラー関数を使用できるようになります。グローバルハンドラーは、$fh.sync.interceptRequest でデータセットにハンドラーが割り当てられていない場合にのみ使用されます。

$fh.sync.globalInterceptRequest(function(dataset_id, interceptorParams, cb){

});

var emitter = $fh.sync.getEventEmitter();

なし

var emitter = $fh.sync.getEventEmitter();
emitter.once('sync:ready', function(){
  //do something here
});