1 /*

     2 YUI 3.10.3 (build 2fb5187)

     3 Copyright 2013 Yahoo! Inc. All rights reserved.

     4 Licensed under the BSD License.

     5 http://yuilibrary.com/license/

     6 */

     7 

     8 YUI.add('model-sync-rest', function (Y, NAME) {

     9 

    10 /**

    11 An extension which provides a RESTful XHR sync implementation that can be mixed

    12 into a Model or ModelList subclass.

    13 

    14 @module app

    15 @submodule model-sync-rest

    16 @since 3.6.0

    17 **/

    18 

    19 var Lang = Y.Lang;

    20 

    21 /**

    22 An extension which provides a RESTful XHR sync implementation that can be mixed

    23 into a Model or ModelList subclass.

    24 

    25 This makes it trivial for your Model or ModelList subclasses communicate and

    26 transmit their data via RESTful XHRs. In most cases you'll only need to provide

    27 a value for `root` when sub-classing `Y.Model`.

    28 

    29     Y.User = Y.Base.create('user', Y.Model, [Y.ModelSync.REST], {

    30         root: '/users'

    31     });

    32 

    33     Y.Users = Y.Base.create('users', Y.ModelList, [Y.ModelSync.REST], {

    34         // By convention `Y.User`'s `root` will be used for the lists' URL.

    35         model: Y.User

    36     });

    37 

    38     var users = new Y.Users();

    39 

    40     // GET users list from: "/users"

    41     users.load(function () {

    42         var firstUser = users.item(0);

    43 

    44         firstUser.get('id'); // => "1"

    45 

    46         // PUT updated user data at: "/users/1"

    47         firstUser.set('name', 'Eric').save();

    48     });

    49 

    50 @class ModelSync.REST

    51 @extensionfor Model

    52 @extensionfor ModelList

    53 @since 3.6.0

    54 **/

    55 function RESTSync() {}

    56 

    57 /**

    58 A request authenticity token to validate HTTP requests made by this extension

    59 with the server when the request results in changing persistent state. This

    60 allows you to protect your server from Cross-Site Request Forgery attacks.

    61 

    62 A CSRF token provided by the server can be embedded in the HTML document and

    63 assigned to `YUI.Env.CSRF_TOKEN` like this:

    64 

    65     <script>

    66         YUI.Env.CSRF_TOKEN = {{session.authenticityToken}};

    67     </script>

    68 

    69 The above should come after YUI seed file so that `YUI.Env` will be defined.

    70 

    71 **Note:** This can be overridden on a per-request basis. See `sync()` method.

    72 

    73 When a value for the CSRF token is provided, either statically or via `options`

    74 passed to the `save()` and `destroy()` methods, the applicable HTTP requests

    75 will have a `X-CSRF-Token` header added with the token value.

    76 

    77 @property CSRF_TOKEN

    78 @type String

    79 @default YUI.Env.CSRF_TOKEN

    80 @static

    81 @since 3.6.0

    82 **/

    83 RESTSync.CSRF_TOKEN = YUI.Env.CSRF_TOKEN;

    84 

    85 /**

    86 Static flag to use the HTTP POST method instead of PUT or DELETE.

    87 

    88 If the server-side HTTP framework isn't RESTful, setting this flag to `true`

    89 will cause all PUT and DELETE requests to instead use the POST HTTP method, and

    90 add a `X-HTTP-Method-Override` HTTP header with the value of the method type

    91 which was overridden.

    92 

    93 @property EMULATE_HTTP

    94 @type Boolean

    95 @default false

    96 @static

    97 @since 3.6.0

    98 **/

    99 RESTSync.EMULATE_HTTP = false;

   100 

   101 /**

   102 Default headers used with all XHRs.

   103 

   104 By default the `Accept` and `Content-Type` headers are set to

   105 "application/json", this signals to the HTTP server to process the request

   106 bodies as JSON and send JSON responses. If you're sending and receiving content

   107 other than JSON, you can override these headers and the `parse()` and

   108 `serialize()` methods.

   109 

   110 **Note:** These headers will be merged with any request-specific headers, and

   111 the request-specific headers will take precedence.

   112 

   113 @property HTTP_HEADERS

   114 @type Object

   115 @default

   116     {

   117         "Accept"      : "application/json",

   118         "Content-Type": "application/json"

   119     }

   120 @static

   121 @since 3.6.0

   122 **/

   123 RESTSync.HTTP_HEADERS = {

   124     'Accept'      : 'application/json',

   125     'Content-Type': 'application/json'

   126 };

   127 

   128 /**

   129 Static mapping of RESTful HTTP methods corresponding to CRUD actions.

   130 

   131 @property HTTP_METHODS

   132 @type Object

   133 @default

   134     {

   135         "create": "POST",

   136         "read"  : "GET",

   137         "update": "PUT",

   138         "delete": "DELETE"

   139     }

   140 @static

   141 @since 3.6.0

   142 **/

   143 RESTSync.HTTP_METHODS = {

   144     'create': 'POST',

   145     'read'  : 'GET',

   146     'update': 'PUT',

   147     'delete': 'DELETE'

   148 };

   149 

   150 /**

   151 The number of milliseconds before the XHRs will timeout/abort. This defaults to

   152 30 seconds.

   153 

   154 **Note:** This can be overridden on a per-request basis. See `sync()` method.

   155 

   156 @property HTTP_TIMEOUT

   157 @type Number

   158 @default 30000

   159 @static

   160 @since 3.6.0

   161 **/

   162 RESTSync.HTTP_TIMEOUT = 30000;

   163 

   164 /**

   165 Properties that shouldn't be turned into ad-hoc attributes when passed to a

   166 Model or ModelList constructor.

   167 

   168 @property _NON_ATTRS_CFG

   169 @type Array

   170 @default ["root", "url"]

   171 @static

   172 @protected

   173 @since 3.6.0

   174 **/

   175 RESTSync._NON_ATTRS_CFG = ['root', 'url'];

   176 

   177 RESTSync.prototype = {

   178 

   179     // -- Public Properties ----------------------------------------------------

   180 

   181     /**

   182     A string which represents the root or collection part of the URL which

   183     relates to a Model or ModelList. Usually this value should be same for all

   184     instances of a specific Model/ModelList subclass.

   185 

   186     When sub-classing `Y.Model`, usually you'll only need to override this

   187     property, which lets the URLs for the XHRs be generated by convention. If

   188     the `root` string ends with a trailing-slash, XHR URLs will also end with a

   189     "/", and if the `root` does not end with a slash, neither will the XHR URLs.

   190 

   191     @example

   192         Y.User = Y.Base.create('user', Y.Model, [Y.ModelSync.REST], {

   193             root: '/users'

   194         });

   195 

   196         var currentUser, newUser;

   197 

   198         // GET the user data from: "/users/123"

   199         currentUser = new Y.User({id: '123'}).load();

   200 

   201         // POST the new user data to: "/users"

   202         newUser = new Y.User({name: 'Eric Ferraiuolo'}).save();

   203 

   204     When sub-classing `Y.ModelList`, usually you'll want to ignore configuring

   205     the `root` and simply rely on the build-in convention of the list's

   206     generated URLs defaulting to the `root` specified by the list's `model`.

   207 

   208     @property root

   209     @type String

   210     @default ""

   211     @since 3.6.0

   212     **/

   213     root: '',

   214 

   215     /**

   216     A string which specifies the URL to use when making XHRs, if not value is

   217     provided, the URLs used to make XHRs will be generated by convention.

   218 

   219     While a `url` can be provided for each Model/ModelList instance, usually

   220     you'll want to either rely on the default convention or provide a tokenized

   221     string on the prototype which can be used for all instances.

   222 

   223     When sub-classing `Y.Model`, you will probably be able to rely on the

   224     default convention of generating URLs in conjunction with the `root`

   225     property and whether the model is new or not (i.e. has an `id`). If the

   226     `root` property ends with a trailing-slash, the generated URL for the

   227     specific model will also end with a trailing-slash.

   228 

   229     @example

   230         Y.User = Y.Base.create('user', Y.Model, [Y.ModelSync.REST], {

   231             root: '/users/'

   232         });

   233 

   234         var currentUser, newUser;

   235 

   236         // GET the user data from: "/users/123/"

   237         currentUser = new Y.User({id: '123'}).load();

   238 

   239         // POST the new user data to: "/users/"

   240         newUser = new Y.User({name: 'Eric Ferraiuolo'}).save();

   241 

   242     If a `url` is specified, it will be processed by `Y.Lang.sub()`, which is

   243     useful when the URLs for a Model/ModelList subclass match a specific pattern

   244     and can use simple replacement tokens; e.g.:

   245 

   246     @example

   247         Y.User = Y.Base.create('user', Y.Model, [Y.ModelSync.REST], {

   248             root: '/users',

   249             url : '/users/{username}'

   250         });

   251 

   252     **Note:** String subsitituion of the `url` only use string an number values

   253     provided by this object's attribute and/or the `options` passed to the

   254     `getURL()` method. Do not expect something fancy to happen with Object,

   255     Array, or Boolean values, they will simply be ignored.

   256 

   257     If your URLs have plural roots or collection URLs, while the specific item

   258     resources are under a singular name, e.g. "/users" (plural) and "/user/123"

   259     (singular), you'll probably want to configure the `root` and `url`

   260     properties like this:

   261 

   262     @example

   263         Y.User = Y.Base.create('user', Y.Model, [Y.ModelSync.REST], {

   264             root: '/users',

   265             url : '/user/{id}'

   266         });

   267 

   268         var currentUser, newUser;

   269 

   270         // GET the user data from: "/user/123"

   271         currentUser = new Y.User({id: '123'}).load();

   272 

   273         // POST the new user data to: "/users"

   274         newUser = new Y.User({name: 'Eric Ferraiuolo'}).save();

   275 

   276     When sub-classing `Y.ModelList`, usually you'll be able to rely on the

   277     associated `model` to supply its `root` to be used as the model list's URL.

   278     If this needs to be customized, you can provide a simple string for the

   279     `url` property.

   280 

   281     @example

   282         Y.Users = Y.Base.create('users', Y.ModelList, [Y.ModelSync.REST], {

   283             // Leverages `Y.User`'s `root`, which is "/users".

   284             model: Y.User

   285         });

   286 

   287         // Or specified explicitly...

   288 

   289         Y.Users = Y.Base.create('users', Y.ModelList, [Y.ModelSync.REST], {

   290             model: Y.User,

   291             url  : '/users'

   292         });

   293 

   294     @property url

   295     @type String

   296     @default ""

   297     @since 3.6.0

   298     **/

   299     url: '',

   300 

   301     // -- Lifecycle Methods ----------------------------------------------------

   302 

   303     initializer: function (config) {

   304         config || (config = {});

   305 

   306         // Overrides `root` at the instance level.

   307         if ('root' in config) {

   308             this.root = config.root || '';

   309         }

   310 

   311         // Overrides `url` at the instance level.

   312         if ('url' in config) {

   313             this.url = config.url || '';

   314         }

   315     },

   316 

   317     // -- Public Methods -------------------------------------------------------

   318 

   319     /**

   320     Returns the URL for this model or model list for the given `action` and

   321     `options`, if specified.

   322 

   323     This method correctly handles the variations of `root` and `url` values and

   324     is called by the `sync()` method to get the URLs used to make the XHRs.

   325 

   326     You can override this method if you need to provide a specific

   327     implementation for how the URLs of your Model and ModelList subclasses need

   328     to be generated.

   329 

   330     @method getURL

   331     @param {String} [action] Optional `sync()` action for which to generate the

   332         URL.

   333     @param {Object} [options] Optional options which may be used to help

   334         generate the URL.

   335     @return {String} this model's or model list's URL for the the given

   336         `action` and `options`.

   337     @since 3.6.0

   338     **/

   339     getURL: function (action, options) {

   340         var root = this.root,

   341             url  = this.url;

   342 

   343         // If this is a model list, use its `url` and substitute placeholders,

   344         // but default to the `root` of its `model`. By convention a model's

   345         // `root` is the location to a collection resource.

   346         if (this._isYUIModelList) {

   347             if (!url) {

   348                 return this.model.prototype.root;

   349             }

   350 

   351             return this._substituteURL(url, Y.merge(this.getAttrs(), options));

   352         }

   353 

   354         // Assume `this` is a model.

   355 

   356         // When a model is new, i.e. has no `id`, the `root` should be used. By

   357         // convention a model's `root` is the location to a collection resource.

   358         // The model's `url` will be used as a fallback if `root` isn't defined.

   359         if (root && (action === 'create' || this.isNew())) {

   360             return root;

   361         }

   362 

   363         // When a model's `url` is not provided, we'll generate a URL to use by

   364         // convention. This will combine the model's `id` with its configured

   365         // `root` and add a trailing-slash if the root ends with "/".

   366         if (!url) {

   367             return this._joinURL(this.getAsURL('id') || '');

   368         }

   369 

   370         // Substitute placeholders in the `url` with URL-encoded values from the

   371         // model's attribute values or the specified `options`.

   372         return this._substituteURL(url, Y.merge(this.getAttrs(), options));

   373     },

   374 

   375     /**

   376     Called to parse the response object returned from `Y.io()`. This method

   377     receives the full response object and is expected to "prep" a response which

   378     is suitable to pass to the `parse()` method.

   379 

   380     By default the response body is returned (`responseText`), because it

   381     usually represents the entire entity of this model on the server.

   382 

   383     If you need to parse data out of the response's headers you should do so by

   384     overriding this method. If you'd like the entire response object from the

   385     XHR to be passed to your `parse()` method, you can simply assign this

   386     property to `false`.

   387 

   388     @method parseIOResponse

   389     @param {Object} response Response object from `Y.io()`.

   390     @return {Any} The modified response to pass along to the `parse()` method.

   391     @since 3.7.0

   392     **/

   393     parseIOResponse: function (response) {

   394         return response.responseText;

   395     },

   396 

   397     /**

   398     Serializes `this` model to be used as the HTTP request entity body.

   399 

   400     By default this model will be serialized to a JSON string via its `toJSON()`

   401     method.

   402 

   403     You can override this method when the HTTP server expects a different

   404     representation of this model's data that is different from the default JSON

   405     serialization. If you're sending and receive content other than JSON, be

   406     sure change the `Accept` and `Content-Type` `HTTP_HEADERS` as well.

   407 

   408     **Note:** A model's `toJSON()` method can also be overridden. If you only

   409     need to modify which attributes are serialized to JSON, that's a better

   410     place to start.

   411 

   412     @method serialize

   413     @param {String} [action] Optional `sync()` action for which to generate the

   414         the serialized representation of this model.

   415     @return {String} serialized HTTP request entity body.

   416     @since 3.6.0

   417     **/

   418     serialize: function (action) {

   419         return Y.JSON.stringify(this);

   420     },

   421 

   422     /**

   423     Communicates with a RESTful HTTP server by sending and receiving data via

   424     XHRs. This method is called internally by load(), save(), and destroy().

   425 

   426     The URL used for each XHR will be retrieved by calling the `getURL()` method

   427     and passing it the specified `action` and `options`.

   428 

   429     This method relies heavily on standard RESTful HTTP conventions

   430 

   431     @method sync

   432     @param {String} action Sync action to perform. May be one of the following:

   433 

   434       * `create`: Store a newly-created model for the first time.

   435       * `delete`: Delete an existing model.

   436       * `read`  : Load an existing model.

   437       * `update`: Update an existing model.

   438 

   439     @param {Object} [options] Sync options:

   440       @param {String} [options.csrfToken] The authenticity token used by the

   441         server to verify the validity of this request and protected against CSRF

   442         attacks. This overrides the default value provided by the static

   443         `CSRF_TOKEN` property.

   444       @param {Object} [options.headers] The HTTP headers to mix with the default

   445         headers specified by the static `HTTP_HEADERS` property.

   446       @param {Number} [options.timeout] The number of milliseconds before the

   447         request will timeout and be aborted. This overrides the default provided

   448         by the static `HTTP_TIMEOUT` property.

   449     @param {Function} [callback] Called when the sync operation finishes.

   450       @param {Error|null} callback.err If an error occurred, this parameter will

   451         contain the error. If the sync operation succeeded, _err_ will be

   452         falsy.

   453       @param {Any} [callback.response] The server's response.

   454     **/

   455     sync: function (action, options, callback) {

   456         options || (options = {});

   457 

   458         var url       = this.getURL(action, options),

   459             method    = RESTSync.HTTP_METHODS[action],

   460             headers   = Y.merge(RESTSync.HTTP_HEADERS, options.headers),

   461             timeout   = options.timeout || RESTSync.HTTP_TIMEOUT,

   462             csrfToken = options.csrfToken || RESTSync.CSRF_TOKEN,

   463             entity;

   464 

   465         // Prepare the content if we are sending data to the server.

   466         if (method === 'POST' || method === 'PUT') {

   467             entity = this.serialize(action);

   468         } else {

   469             // Remove header, no content is being sent.

   470             delete headers['Content-Type'];

   471         }

   472 

   473         // Setup HTTP emulation for older servers if we need it.

   474         if (RESTSync.EMULATE_HTTP &&

   475                 (method === 'PUT' || method === 'DELETE')) {

   476 

   477             // Pass along original method type in the headers.

   478             headers['X-HTTP-Method-Override'] = method;

   479 

   480             // Fall-back to using POST method type.

   481             method = 'POST';

   482         }

   483 

   484         // Add CSRF token to HTTP request headers if one is specified and the

   485         // request will cause side effects on the server.

   486         if (csrfToken &&

   487                 (method === 'POST' || method === 'PUT' || method === 'DELETE')) {

   488 

   489             headers['X-CSRF-Token'] = csrfToken;

   490         }

   491 

   492         this._sendSyncIORequest({

   493             action  : action,

   494             callback: callback,

   495             entity  : entity,

   496             headers : headers,

   497             method  : method,

   498             timeout : timeout,

   499             url     : url

   500         });

   501     },

   502 

   503     // -- Protected Methods ----------------------------------------------------

   504 

   505     /**

   506     Joins the `root` URL to the specified `url`, normalizing leading/trailing

   507     "/" characters.

   508 

   509     @example

   510         model.root = '/foo'

   511         model._joinURL('bar');  // => '/foo/bar'

   512         model._joinURL('/bar'); // => '/foo/bar'

   513 

   514         model.root = '/foo/'

   515         model._joinURL('bar');  // => '/foo/bar/'

   516         model._joinURL('/bar'); // => '/foo/bar/'

   517 

   518     @method _joinURL

   519     @param {String} url URL to append to the `root` URL.

   520     @return {String} Joined URL.

   521     @protected

   522     @since 3.6.0

   523     **/

   524     _joinURL: function (url) {

   525         var root = this.root;

   526 

   527         if (!(root || url)) {

   528             return '';

   529         }

   530 

   531         if (url.charAt(0) === '/') {

   532             url = url.substring(1);

   533         }

   534 

   535         // Combines the `root` with the `url` and adds a trailing-slash if the

   536         // `root` has a trailing-slash.

   537         return root && root.charAt(root.length - 1) === '/' ?

   538                 root + url + '/' :

   539                 root + '/' + url;

   540     },

   541 

   542 

   543     /**

   544     Calls both public, overrideable methods: `parseIOResponse()`, then `parse()`

   545     and returns the result.

   546 

   547     This will call into `parseIOResponse()`, if it's defined as a method,

   548     passing it the full response object from the XHR and using its return value

   549     to pass along to the `parse()`. This enables developers to easily parse data

   550     out of the response headers which should be used by the `parse()` method.

   551 

   552     @method _parse

   553     @param {Object} response Response object from `Y.io()`.

   554     @return {Object|Object[]} Attribute hash or Array of model attribute hashes.

   555     @protected

   556     @since 3.7.0

   557     **/

   558     _parse: function (response) {

   559         // When `parseIOResponse` is defined as a method, it will be invoked and

   560         // the result will become the new response object that the `parse()`

   561         // will be invoked with.

   562         if (typeof this.parseIOResponse === 'function') {

   563             response = this.parseIOResponse(response);

   564         }

   565 

   566         return this.parse(response);

   567     },

   568 

   569     /**

   570     Performs the XHR and returns the resulting `Y.io()` request object.

   571 

   572     This method is called by `sync()`.

   573 

   574     @method _sendSyncIORequest

   575     @param {Object} config An object with the following properties:

   576       @param {String} config.action The `sync()` action being performed.

   577       @param {Function} [config.callback] Called when the sync operation

   578         finishes.

   579       @param {String} [config.entity] The HTTP request entity body.

   580       @param {Object} config.headers The HTTP request headers.

   581       @param {String} config.method The HTTP request method.

   582       @param {Number} [config.timeout] Time until the HTTP request is aborted.

   583       @param {String} config.url The URL of the HTTP resource.

   584     @return {Object} The resulting `Y.io()` request object.

   585     @protected

   586     @since 3.6.0

   587     **/

   588     _sendSyncIORequest: function (config) {

   589         return Y.io(config.url, {

   590             'arguments': {

   591                 action  : config.action,

   592                 callback: config.callback,

   593                 url     : config.url

   594             },

   595 

   596             context: this,

   597             data   : config.entity,

   598             headers: config.headers,

   599             method : config.method,

   600             timeout: config.timeout,

   601 

   602             on: {

   603                 start  : this._onSyncIOStart,

   604                 failure: this._onSyncIOFailure,

   605                 success: this._onSyncIOSuccess,

   606                 end    : this._onSyncIOEnd

   607             }

   608         });

   609     },

   610 

   611     /**

   612     Utility which takes a tokenized `url` string and substitutes its

   613     placeholders using a specified `data` object.

   614 

   615     This method will property URL-encode any values before substituting them.

   616     Also, only expect it to work with String and Number values.

   617 

   618     @example

   619         var url = this._substituteURL('/users/{name}', {id: 'Eric F'});

   620         // => "/users/Eric%20F"

   621 

   622     @method _substituteURL

   623     @param {String} url Tokenized URL string to substitute placeholder values.

   624     @param {Object} data Set of data to fill in the `url`'s placeholders.

   625     @return {String} Substituted URL.

   626     @protected

   627     @since 3.6.0

   628     **/

   629     _substituteURL: function (url, data) {

   630         if (!url) {

   631             return '';

   632         }

   633 

   634         var values = {};

   635 

   636         // Creates a hash of the string and number values only to be used to

   637         // replace any placeholders in a tokenized `url`.

   638         Y.Object.each(data, function (v, k) {

   639             if (Lang.isString(v) || Lang.isNumber(v)) {

   640                 // URL-encode any string or number values.

   641                 values[k] = encodeURIComponent(v);

   642             }

   643         });

   644 

   645         return Lang.sub(url, values);

   646     },

   647 

   648     // -- Event Handlers -------------------------------------------------------

   649 

   650     /**

   651     Called when the `Y.io` request has finished, after "success" or "failure"

   652     has been determined.

   653 

   654     This is a no-op by default, but provides a hook for overriding.

   655 

   656     @method _onSyncIOEnd

   657     @param {String} txId The `Y.io` transaction id.

   658     @param {Object} details Extra details carried through from `sync()`:

   659       @param {String} details.action The sync action performed.

   660       @param {Function} [details.callback] The function to call after syncing.

   661       @param {String} details.url The URL of the requested resource.

   662     @protected

   663     @since 3.6.0

   664     **/

   665     _onSyncIOEnd: function (txId, details) {},

   666 

   667     /**

   668     Called when the `Y.io` request has finished unsuccessfully.

   669 

   670     By default this calls the `details.callback` function passing it the HTTP

   671     status code and message as an error object along with the response body.

   672 

   673     @method _onSyncIOFailure

   674     @param {String} txId The `Y.io` transaction id.

   675     @param {Object} res The `Y.io` response object.

   676     @param {Object} details Extra details carried through from `sync()`:

   677       @param {String} details.action The sync action performed.

   678       @param {Function} [details.callback] The function to call after syncing.

   679       @param {String} details.url The URL of the requested resource.

   680     @protected

   681     @since 3.6.0

   682     **/

   683     _onSyncIOFailure: function (txId, res, details) {

   684         var callback = details.callback;

   685 

   686         if (callback) {

   687             callback({

   688                 code: res.status,

   689                 msg : res.statusText

   690             }, res);

   691         }

   692     },

   693 

   694     /**

   695     Called when the `Y.io` request has finished successfully.

   696 

   697     By default this calls the `details.callback` function passing it the

   698     response body.

   699 

   700     @method _onSyncIOSuccess

   701     @param {String} txId The `Y.io` transaction id.

   702     @param {Object} res The `Y.io` response object.

   703     @param {Object} details Extra details carried through from `sync()`:

   704       @param {String} details.action The sync action performed.

   705       @param {Function} [details.callback] The function to call after syncing.

   706       @param {String} details.url The URL of the requested resource.

   707     @protected

   708     @since 3.6.0

   709     **/

   710     _onSyncIOSuccess: function (txId, res, details) {

   711         var callback = details.callback;

   712 

   713         if (callback) {

   714             callback(null, res);

   715         }

   716     },

   717 

   718     /**

   719     Called when the `Y.io` request is made.

   720 

   721     This is a no-op by default, but provides a hook for overriding.

   722 

   723     @method _onSyncIOStart

   724     @param {String} txId The `Y.io` transaction id.

   725     @param {Object} details Extra details carried through from `sync()`:

   726       @param {String} detials.action The sync action performed.

   727       @param {Function} [details.callback] The function to call after syncing.

   728       @param {String} details.url The URL of the requested resource.

   729     @protected

   730     @since 3.6.0

   731     **/

   732     _onSyncIOStart: function (txId, details) {}

   733 };

   734 

   735 // -- Namespace ----------------------------------------------------------------

   736 

   737 Y.namespace('ModelSync').REST = RESTSync;

   738 

   739 

   740 }, '3.10.3', {"requires": ["model", "io-base", "json-stringify"]});