Source: management/index.js

  1. import urljoin from 'url-join';
  3. import RequestBuilder from '../helper/request-builder';
  4. import assert from '../helper/assert';
  5. import responseHandler from '../helper/response-handler';
  7. /**
  8.  * Auth0 Management API Client (methods allowed to be called from the browser only)
  9.  * @constructor
  10.  * @param {Object} options
  11.  * @param {Object} options.domain your Auth0 acount domain
  12.  * @param {Object} options.token a valid API token
  13.  */
  14. function Management(options) {
  15.   /* eslint-disable */
  16.   assert.check(
  17.     options,
  18.     { type: 'object', message: 'options parameter is not valid' },
  19.     {
  20.       domain: { type: 'string', message: 'domain option is required' },
  21.       token: { type: 'string', message: 'token option is required' },
  22.       _sendTelemetry: {
  23.         optional: true,
  24.         type: 'boolean',
  25.         message: '_sendTelemetry option is not valid'
  26.       },
  27.       _telemetryInfo: {
  28.         optional: true,
  29.         type: 'object',
  30.         message: '_telemetryInfo option is not valid'
  31.       }
  32.     }
  33.   );
  34.   /* eslint-enable */
  36.   this.baseOptions = options;
  38.   this.baseOptions.headers = {
  39.     Authorization: 'Bearer ' + this.baseOptions.token
  40.   };
  42.   this.request = new RequestBuilder(this.baseOptions);
  43.   this.baseOptions.rootUrl = urljoin(
  44.     'https://' + this.baseOptions.domain,
  45.     'api',
  46.     'v2'
  47.   );
  48. }
  50. /**
  51.  * @callback userCallback
  52.  * @param {Error} [err] failure reason for the failed request to Management API
  53.  * @param {Object} [result] user profile
  54.  * @memberof Management.prototype
  55.  */
  57. /**
  58.  * Returns the user profile
  59.  *
  60.  * @method getUser
  61.  * @param {String} userId identifier of the user to retrieve
  62.  * @param {userCallback} cb
  63.  * @see https://auth0.com/docs/api/management/v2#!/Users/get_users_by_id
  64.  * @memberof Management.prototype
  65.  */
  66. Management.prototype.getUser = function(userId, cb) {
  67.   var url;
  69.   assert.check(userId, {
  70.     type: 'string',
  71.     message: 'userId parameter is not valid'
  72.   });
  73.   assert.check(cb, { type: 'function', message: 'cb parameter is not valid' });
  75.   url = urljoin(this.baseOptions.rootUrl, 'users', userId);
  77.   return this.request.get(url).end(responseHandler(cb, { ignoreCasing: true }));
  78. };
  80. /**
  81.  * Updates the user metdata. It will patch the user metdata with the attributes sent.
  82.  *
  83.  *
  84.  * @method patchUserMetadata
  85.  * @param {String} userId
  86.  * @param {Object} userMetadata
  87.  * @param {userCallback} cb
  88.  * @see   {@link https://auth0.com/docs/api/management/v2#!/Users/patch_users_by_id}
  89.  * @memberof Management.prototype
  90.  */
  91. Management.prototype.patchUserMetadata = function(userId, userMetadata, cb) {
  92.   var url;
  94.   assert.check(userId, {
  95.     type: 'string',
  96.     message: 'userId parameter is not valid'
  97.   });
  98.   assert.check(userMetadata, {
  99.     type: 'object',
  100.     message: 'userMetadata parameter is not valid'
  101.   });
  102.   assert.check(cb, { type: 'function', message: 'cb parameter is not valid' });
  104.   url = urljoin(this.baseOptions.rootUrl, 'users', userId);
  106.   return this.request
  107.     .patch(url)
  108.     .send({ user_metadata: userMetadata })
  109.     .end(responseHandler(cb, { ignoreCasing: true }));
  110. };
  112. /**
  113.  * Updates the user attributes. It will patch the user attributes that the server allows it.
  114.  *
  115.  * @method patchUserAttributes
  116.  * @param {String} userId
  117.  * @param {Object} user
  118.  * @param {userCallback} cb
  119.  * @see   {@link https://auth0.com/docs/api/management/v2#!/Users/patch_users_by_id}
  120.  * @memberof Management.prototype
  121.  */
  122. Management.prototype.patchUserAttributes = function(userId, user, cb) {
  123.   var url;
  125.   assert.check(userId, {
  126.     type: 'string',
  127.     message: 'userId parameter is not valid'
  128.   });
  129.   assert.check(user, {
  130.     type: 'object',
  131.     message: 'user parameter is not valid'
  132.   });
  133.   assert.check(cb, { type: 'function', message: 'cb parameter is not valid' });
  135.   url = urljoin(this.baseOptions.rootUrl, 'users', userId);
  137.   return this.request
  138.     .patch(url)
  139.     .send(user)
  140.     .end(responseHandler(cb, { ignoreCasing: true }));
  141. };
  143. /**
  144.  * Link two users
  145.  *
  146.  * @method linkUser
  147.  * @param {String} userId
  148.  * @param {String} secondaryUserToken
  149.  * @param {userCallback} cb
  150.  * @see   {@link https://auth0.com/docs/api/management/v2#!/Users/post_identities}
  151.  * @memberof Management.prototype
  152.  */
  153. Management.prototype.linkUser = function(userId, secondaryUserToken, cb) {
  154.   var url;
  155.   /* eslint-disable */
  156.   assert.check(userId, {
  157.     type: 'string',
  158.     message: 'userId parameter is not valid'
  159.   });
  160.   assert.check(secondaryUserToken, {
  161.     type: 'string',
  162.     message: 'secondaryUserToken parameter is not valid'
  163.   });
  164.   assert.check(cb, { type: 'function', message: 'cb parameter is not valid' });
  165.   /* eslint-enable */
  167.   url = urljoin(this.baseOptions.rootUrl, 'users', userId, 'identities');
  169.   return this.request
  170.     .post(url)
  171.     .send({ link_with: secondaryUserToken })
  172.     .end(responseHandler(cb, { ignoreCasing: true }));
  173. };
  175. export default Management;