management/index.js

  1. /** @module management */
  3. var util = require('util');
  5. var pkg = require('../../package.json');
  6. var utils = require('../utils');
  7. var jsonToBase64 = utils.jsonToBase64;
  8. var ArgumentError = require('../exceptions').ArgumentError;
  10. // Managers.
  11. var ClientsManager = require('./ClientsManager');
  12. var UsersManager = require('./UsersManager');
  13. var ConnectionsManager = require('./ConnectionsManager');
  14. var BlacklistedTokensManager = require('./BlacklistedTokensManager');
  15. var RulesManager = require('./RulesManager');
  16. var DeviceCredentialsManager = require('./DeviceCredentialsManager');
  17. var EmailProviderManager = require('./EmailProviderManager');
  18. var StatsManager = require('./StatsManager');
  19. var TenantManager = require('./TenantManager');
  20. var JobsManager = require('./JobsManager');
  21. var TicketsManager = require('./TicketsManager');
  22. var LogsManager = require('./LogsManager');
  24. var BASE_URL_FORMAT = 'https://%s/api/v2';
  27. /**
  28.  * @class ManagementClient
  29.  * Management API SDK.
  30.  *
  31.  * The Auth0 Management API is meant to be used by back-end servers or trusted
  32.  * parties performing administrative tasks. Generally speaking, anything that
  33.  * can be done through the Auth0 dashboard (and more) can also be done through
  34.  * this API.
  35.  * @constructor
  36.  * @memberOf module:management
  37.  *
  38.  * @example <caption>
  39.  *   Initialize your client class with an API v2 token (you can generate one
  40.  *   <a href="https://auth0.com/docs/apiv2">here</a>) and a domain.
  41.  * </caption>
  42.  *
  43.  * var ManagementClient = require('auth0').ManagementClient;
  44.  * var auth0 = new ManagementClient({
  45.  *   token: '{YOUR_API_V2_TOKEN}',
  46.  *   domain: '{YOUR_ACCOUNT}.auth0.com'
  47.  * });
  48.  *
  49.  * @param   {Object}  options           Options for the ManagementClient SDK.
  50.  * @param   {String}  options.token     API access token.
  51.  * @param   {String}  [options.domain]  ManagementClient server domain.
  52.  */
  53. var ManagementClient = function (options) {
  54.   if (!options || typeof options !== 'object') {
  55.     throw new ArgumentError('Management API SDK options must be an object');
  56.   }
  58.   if (!options.token || options.token.length === 0) {
  59.     throw new ArgumentError('An access token must be provided');
  60.   }
  62.   if (!options.domain || options.domain.length === 0) {
  63.     throw new ArgumentError('Must provide a domain');
  64.   }
  66.   var managerOptions = {
  67.     headers: {
  68.       'Authorization': 'Bearer ' + options.token,
  69.       'User-agent': 'node.js/' + process.version.replace('v', ''),
  70.       'Content-Type': 'application/json'
  71.     },
  72.     baseUrl: util.format(BASE_URL_FORMAT, options.domain)
  73.   };
  75.   if (options.telemetry !== false) {
  76.     var telemetry = jsonToBase64(options.clientInfo || this.getClientInfo());
  78.     managerOptions.headers['Auth0-Client'] = telemetry;
  79.   }
  81.   /**
  82.    * Simple abstraction for performing CRUD operations on the
  83.    * clients endpoint.
  84.    *
  85.    * @type {ClientsManager}
  86.    */
  87.   this.clients = new ClientsManager(managerOptions);
  89.   /**
  90.    * Simple abstraction for performing CRUD operations on the
  91.    * users endpoint.
  92.    *
  93.    * @type {UsersManager}
  94.    */
  95.   this.users = new UsersManager(managerOptions);
  97.   /**
  98.    * Simple abstraction for performing CRUD operations on the
  99.    * connections endpoint.
  100.    *
  101.    * @type {ConnectionsManager}
  102.    */
  103.   this.connections = new ConnectionsManager(managerOptions);
  105.   /**
  106.    * Simple abstraction for performing CRUD operations on the
  107.    * device credentials endpoint.
  108.    *
  109.    * @type {DeviceCredentialsManager}
  110.    */
  111.   this.deviceCredentials = new DeviceCredentialsManager(managerOptions);
  113.   /**
  114.    * Simple abstraction for performing CRUD operations on the
  115.    * rules endpoint.
  116.    *
  117.    * @type {RulesManager}
  118.    */
  119.   this.rules = new RulesManager(managerOptions);
  121.   /**
  122.    * Simple abstraction for performing CRUD operations on the
  123.    * blacklisted tokens endpoint.
  124.    *
  125.    * @type {BlacklistedtokensManager}
  126.    */
  127.   this.blacklistedTokens = new BlacklistedTokensManager(managerOptions);
  129.   /**
  130.    * Simple abstraction for performing CRUD operations on the
  131.    * email provider endpoint.
  132.    *
  133.    * @type {EmailProviderManager}
  134.    */
  135.   this.emailProvider = new EmailProviderManager(managerOptions);
  137.   /**
  138.    * ManagementClient account statistics manager.
  139.    *
  140.    * @type {StatsManager}
  141.    */
  142.   this.stats = new StatsManager(managerOptions);
  144.   /**
  145.    * ManagementClient tenant settings manager.
  146.    *
  147.    * @type {TenantManager}
  148.    */
  149.   this.tenant = new TenantManager(managerOptions);
  151.   /**
  152.    * Jobs manager.
  153.    *
  154.    * @type {JobsManager}
  155.    */
  156.   this.jobs = new JobsManager(managerOptions);
  158.   /**
  159.    * Tickets manager.
  160.    *
  161.    * @type {TicketsManager}
  162.    */
  163.   this.tickets = new TicketsManager(managerOptions);
  165.   /**
  166.    * Logs manager.
  167.    *
  168.    * @type {LogsManager}
  169.    */
  170.   this.logs = new LogsManager(managerOptions);
  171. };
  174. /**
  175.  * Return an object with information about the current client,
  176.  *
  177.  * @method    getClientInfo
  178.  * @memberOf  module:management.ManagementClient.prototype
  179.  *
  180.  * @return {Object}   Object containing client information.
  181.  */
  182. ManagementClient.prototype.getClientInfo = function () {
  183.   var clientInfo = {
  184.     name: 'node-auth0',
  185.     version: pkg.version,
  186.     dependencies: [],
  187.     environment: [{
  188.       name: 'node.js',
  189.       version: process.version.replace('v', '')
  190.     }]
  191.   };
  192.   // Add the dependencies to the client info object.
  193.   Object
  194.     .keys(pkg.dependencies)
  195.     .forEach(function (name) {
  196.       clientInfo.dependencies.push({
  197.         name: name,
  198.         version: pkg.dependencies[name]
  199.       });
  200.     });
  202.   return clientInfo;
  203. };
  206. /**
  207.  * Get all connections.
  208.  *
  209.  * @method    getConnections
  210.  * @memberOf  module:management.ManagementClient.prototype
  211.  *
  212.  * @example
  213.  * management.getConnections(function (err, connections) {
  214.  *   console.log(connections.length);
  215.  * });
  216.  *
  217.  * @param   {Object}    data     Connection data object.
  218.  * @param   {Function}  [cb]     Callback function.
  219.  *
  220.  * @return  {Promise|undefined}
  221.  */
  222. utils.wrapPropertyMethod(ManagementClient, 'getConnections', 'connections.getAll');
  225. /**
  226.  * Create a new connection.
  227.  *
  228.  * @method    createConnection
  229.  * @memberOf  module:management.ManagementClient.prototype
  230.  *
  231.  * @example
  232.  * management.createConnection(data, function (err) {
  233.  *   if (err) {
  234.  *     // Handle error.
  235.  *   }
  236.  *
  237.  *   // Conection created.
  238.  * });
  239.  *
  240.  * @param   {Object}    data     Connection data object.
  241.  * @param   {Function}  [cb]     Callback function.
  242.  *
  243.  * @return  {Promise|undefined}
  244.  */
  245. utils.wrapPropertyMethod(ManagementClient, 'createConnection', 'connections.create');
  248. /**
  249.  * Get an Auth0 connection.
  250.  *
  251.  * @method    getConnection
  252.  * @memberOf  module:management.ManagementClient.prototype
  253.  *
  254.  * @example
  255.  * management.getConnection({ id: CONNECTION_ID }, function (err, connection) {
  256.  *   if (err) {
  257.  *     // Handle error.
  258.  *   }
  259.  *
  260.  *   console.log(connection);
  261.  * });
  262.  *
  263.  * @param   {Object}    params          Connection parameters.
  264.  * @param   {String}    params.id       Connection ID.
  265.  * @param   {Function}  [cb]            Callback function.
  266.  *
  267.  * @return  {Promise|undefined}
  268.  */
  269. utils.wrapPropertyMethod(ManagementClient, 'getConnection', 'connections.get');
  272. /**
  273.  * Delete an existing connection.
  274.  *
  275.  * @method    deleteConnection
  276.  * @memberOf  module:management.ManagementClient.prototype
  277.  *
  278.  * @example
  279.  * management.deleteConnection({ id: CONNECTION_ID }, function (err) {
  280.  *   if (err) {
  281.  *     // Handle error.
  282.  *   }
  283.  *
  284.  *   // Conection deleted.
  285.  * });
  286.  *
  287.  * @param   {Object}    params          Connection parameters.
  288.  * @param   {String}    params.id       Connection ID.
  289.  * @param   {Function}  [cb]            Callback function.
  290.  *
  291.  * @return  {Promise|undefined}
  292.  */
  293. utils.wrapPropertyMethod(ManagementClient, 'deleteConnection', 'connections.delete');
  296. /**
  297.  * Update an existing connection.
  298.  *
  299.  * @method    updateConnection
  300.  * @memberOf  module:management.ManagementClient.prototype
  301.  *
  302.  * @example
  303.  * var data = { name: 'newConnectionName' };
  304.  * var params = { id: CONNECTION_ID };
  305.  *
  306.  * management.updateConnection(params, data, function (err, connection) {
  307.  *   if (err) {
  308.  *     // Handle error.
  309.  *   }
  310.  *
  311.  *   console.log(connection.name);  // 'newConnectionName'
  312.  * });
  313.  *
  314.  * @param   {Object}    params        Conneciton parameters.
  315.  * @param   {String}    params.id     Connection ID.
  316.  * @param   {Object}    data          Updated connection data.
  317.  * @param   {Function}  [cb]          Callback function.
  318.  *
  319.  * @return    {Promise|undefined}
  320.  */
  321. utils.wrapPropertyMethod(ManagementClient, 'updateConnection', 'connections.update');
  324. /**
  325.  * Get all Auth0 clients.
  326.  *
  327.  * @method    getClients
  328.  * @memberOf  module:management.ManagementClient.prototype
  329.  *
  330.  * @example
  331.  * management.getClients(function (err, clients) {
  332.  *   console.log(clients.length);
  333.  * });
  334.  *
  335.  * @param   {Function}  [cb]    Callback function.
  336.  *
  337.  * @return  {Promise|undefined}
  338.  */
  339. utils.wrapPropertyMethod(ManagementClient, 'getClients', 'clients.getAll');
  342. /**
  343.  * Get an Auth0 client.
  344.  *
  345.  * @method    getClient
  346.  * @memberOf  module:management.ManagementClient.prototype
  347.  *
  348.  * @example
  349.  * management.getClient({ client_id: CLIENT_ID }, function (err, client) {
  350.  *   if (err) {
  351.  *     // Handle error.
  352.  *   }
  353.  *
  354.  *   console.log(client);
  355.  * });
  356.  *
  357.  * @param   {Object}    params            Client parameters.
  358.  * @param   {String}    params.client_id  Application client ID.
  359.  * @param   {Function}  [cb]              Callback function.
  360.  *
  361.  * @return  {Promise|undefined}
  362.  */
  363. utils.wrapPropertyMethod(ManagementClient, 'getClient', 'clients.get');
  366. /**
  367.  * Create an Auth0 client.
  368.  *
  369.  * @method    createClient
  370.  * @memberOf  module:management.ManagementClient.prototype
  371.  *
  372.  * @example
  373.  * management.createClient(data, function (err) {
  374.  *   if (err) {
  375.  *     // Handle error.
  376.  *   }
  377.  *
  378.  *   // Client created.
  379.  * });
  380.  *
  381.  * @param   {Object}    data     The client data object.
  382.  * @param   {Function}  [cb]     Callback function.
  383.  *
  384.  * @return  {Promise|undefined}
  385.  */
  386. utils.wrapPropertyMethod(ManagementClient, 'createClient', 'clients.create');
  389. /**
  390.  * Update an Auth0 client.
  391.  *
  392.  * @method    updateClient
  393.  * @memberOf  module:management.ManagementClient.prototype
  394.  *
  395.  * @example
  396.  * var data = { name: 'newClientName' };
  397.  * var params = { client_id: CLIENT_ID };
  398.  *
  399.  * management.updateClient(params, data, function (err, client) {
  400.  *   if (err) {
  401.  *     // Handle error.
  402.  *   }
  403.  *
  404.  *   console.log(client.name);  // 'newClientName'
  405.  * });
  406.  *
  407.  * @param   {Object}    params            Client parameters.
  408.  * @param   {String}    params.client_id  Application client ID.
  409.  * @param   {Object}    data              Updated client data.
  410.  * @param   {Function}  [cb]              Callback function.
  411.  *
  412.  * @return    {Promise|undefined}
  413.  */
  414. utils.wrapPropertyMethod(ManagementClient, 'updateClient', 'clients.update');
  417. /**
  418.  * Delete an Auth0 client.
  419.  *
  420.  * @method    deleteClient
  421.  * @memberOf  module:management.ManagementClient.prototype
  422.  *
  423.  * @example
  424.  * management.deleteClient({ client_id: CLIENT_ID }, function (err) {
  425.  *   if (err) {
  426.  *     // Handle error.
  427.  *   }
  428.  *
  429.  *   // Client deleted.
  430.  * });
  431.  *
  432.  * @param   {Object}    params            Client parameters.
  433.  * @param   {String}    params.client_id  Application client ID.
  434.  * @param   {Function}  [cb]              Callback function.
  435.  *
  436.  * @return  {Promise|undefined}
  437.  */
  438. utils.wrapPropertyMethod(ManagementClient, 'deleteClient', 'clients.delete');
  441. /**
  442.  * Create an Auth0 credential.
  443.  *
  444.  * @method    createDevicePublicKey
  445.  * @memberOf  module:management.ManagementClient.prototype
  446.  *
  447.  * @example
  448.  * management.createConnection(data, function (err) {
  449.  *   if (err) {
  450.  *     // Handle error.
  451.  *   }
  452.  *
  453.  *   // Credential created.
  454.  * });
  455.  *
  456.  * @param   {Object}    data     The device credential data object.
  457.  * @param   {Function}  [cb]     Callback function.
  458.  *
  459.  * @return  {Promise|undefined}
  460.  */
  461. utils.wrapPropertyMethod(ManagementClient, 'createDevicePublicKey', 'deviceCredentials.createPublicKey');
  464. /**
  465.  * Get all Auth0 credentials.
  466.  *
  467.  * @method    getDeviceCredentials
  468.  * @memberOf  module:management.ManagementClient.prototype
  469.  *
  470.  * @example
  471.  * management.getDeviceCredentials(function (err, credentials) {
  472.  *   console.log(credentials.length);
  473.  * });
  474.  *
  475.  * @param   {Function}  [cb]    Callback function.
  476.  *
  477.  * @return  {Promise|undefined}
  478.  */
  479. utils.wrapPropertyMethod(ManagementClient, 'getDeviceCredentials', 'deviceCredentials.getAll');
  482. /**
  483.  * Delete an Auth0 device credential.
  484.  *
  485.  * @method    deleteDeviceCredential
  486.  * @memberOf  module:management.ManagementClient.prototype
  487.  *
  488.  * @example
  489.  * var params = { id: CREDENTIAL_ID };
  490.  *
  491.  * management.deleteDeviceCredential(params, function (err) {
  492.  *   if (err) {
  493.  *     // Handle error.
  494.  *   }
  495.  *
  496.  *   // Credential deleted.
  497.  * });
  498.  *
  499.  * @param   {Object}    params          Credential parameters.
  500.  * @param   {String}    params.id       Device credential ID.
  501.  * @param   {Function}  [cb]            Callback function.
  502.  *
  503.  * @return  {Promise|undefined}
  504.  */
  505. utils.wrapPropertyMethod(ManagementClient, 'deleteDeviceCredential', 'deviceCredentials.delete');
  508. /**
  509.  * Get all rules.
  510.  *
  511.  * @method    getRules
  512.  * @memberOf  module:management.ManagementClient.prototype
  513.  *
  514.  * @example
  515.  * management.getRules(function (err, rules) {
  516.  *   console.log(rules.length);
  517.  * });
  518.  *
  519.  * @param   {Function}  [cb]     Callback function.
  520.  *
  521.  * @return  {Promise|undefined}
  522.  */
  523. utils.wrapPropertyMethod(ManagementClient, 'getRules', 'rules.getAll');
  526. /**
  527.  * Create a new rule.
  528.  *
  529.  * @method    createRules
  530.  * @memberOf  module:management.ManagementClient.prototype
  531.  *
  532.  * @example
  533.  * management.createRule(data, function (err) {
  534.  *   if (err) {
  535.  *     // Handle error.
  536.  *   }
  537.  *
  538.  *   // Rule created.
  539.  * });
  540.  *
  541.  * @param   {Object}    data     Rule data object.
  542.  * @param   {Function}  [cb]     Callback function.
  543.  *
  544.  * @return  {Promise|undefined}
  545.  */
  546. utils.wrapPropertyMethod(ManagementClient, 'createRule', 'rules.create');
  549. /**
  550.  * Get an Auth0 rule.
  551.  *
  552.  * @method    getRule
  553.  * @memberOf  module:management.ManagementClient.prototype
  554.  *
  555.  * @example
  556.  * management.getRule({ id: RULE_ID }, function (err, rule) {
  557.  *   if (err) {
  558.  *     // Handle error.
  559.  *   }
  560.  *
  561.  *   console.log(rule);
  562.  * });
  563.  *
  564.  * @param   {Object}    params        Rule parameters.
  565.  * @param   {String}    params.id     Rule ID.
  566.  * @param   {Function}  [cb]          Callback function.
  567.  *
  568.  * @return  {Promise|undefined}
  569.  */
  570. utils.wrapPropertyMethod(ManagementClient, 'getRule', 'rules.get');
  573. /**
  574.  * Delete an existing rule.
  575.  *
  576.  * @method    deleteRule
  577.  * @memberOf  module:management.ManagementClient.prototype
  578.  *
  579.  * @example
  580.  * auth0.deleteRule({ id: RULE_ID }, function (err) {
  581.  *   if (err) {
  582.  *     // Handle error.
  583.  *   }
  584.  *
  585.  *   // Rule deleted.
  586.  * });
  587.  *
  588.  * @param   {Object}    params        Rule parameters.
  589.  * @param   {String}    params.id     Rule ID.
  590.  * @param   {Function}  [cb]          Callback function.
  591.  *
  592.  * @return  {Promise|undefined}
  593.  */
  594. utils.wrapPropertyMethod(ManagementClient, 'deleteRule', 'rules.delete');
  597. /**
  598.  * Delete an existing rule.
  599.  *
  600.  * @method    updateRule
  601.  * @memberOf  module:management.ManagementClient.prototype
  602.  *
  603.  * @example
  604.  * management.deleteRule({ id: RULE_ID }, function (err) {
  605.  *   if (err) {
  606.  *     // Handle error.
  607.  *   }
  608.  *
  609.  *   // Rule deleted.
  610.  * });
  611.  *
  612.  * @param   {Object}    params        Rule parameters.
  613.  * @param   {String}    params.id     Rule ID.
  614.  * @param   {Function}  [cb]          Callback function.
  615.  *
  616.  * @return  {Promise|undefined}
  617.  */
  618. utils.wrapPropertyMethod(ManagementClient, 'updateRule', 'rules.update');
  621. /**
  622.  * Get all users.
  623.  *
  624.  * @method    getUsers
  625.  * @memberOf  module:management.ManagementClient.prototype
  626.  *
  627.  * @example <caption>
  628.  *   This method takes an optional object as first argument that may be used to
  629.  *   specify pagination settings and the search query.
  630.  * </caption>
  631.  *
  632.  * // Pagination settings.
  633.  * var params = {
  634.  *   per_page: 10,
  635.  *   page: 2
  636.  * };
  637.  *
  638.  * auth0.getUsers(params, function (err, users) {
  639.  *   console.log(users.length);
  640.  * });
  641.  *
  642.  * @param   {Object}    [params]          Users params.
  643.  * @param   {Number}    [params.per_page] Number of users per page.
  644.  * @param   {Number}    [params.page]     Page number.
  645.  * @param   {Function}  [cb]              Callback function.
  646.  *
  647.  * @return  {Promise|undefined}
  648.  */
  649. utils.wrapPropertyMethod(ManagementClient, 'getUsers', 'users.getAll');
  652. /**
  653.  * Get a user by its id.
  654.  *
  655.  * @method    getUser
  656.  * @memberOf  module:management.ManagementClient.prototype
  657.  *
  658.  * @example
  659.  * management.getUser({ id: USER_ID }, function (err, user) {
  660.  *   console.log(user);
  661.  * });
  662.  *
  663.  * @param   {Object}    data      The user data object.
  664.  * @param   {String}    data.id   The user id.
  665.  * @param   {Function}  [cb]      Callback function.
  666.  *
  667.  * @return  {Promise|undefined}
  668.  */
  669. utils.wrapPropertyMethod(ManagementClient, 'getUser', 'users.get');
  672. /**
  673.  * Delete all users.
  674.  *
  675.  * @method    deleteAllUsers
  676.  * @memberOf  module:management.ManagementClient.prototype
  677.  *
  678.  * @example
  679.  * management.deleteAllUsers(function (err) {
  680.  *   if (err) {
  681.  *     // Handle error.
  682.  *   }
  683.  *
  684.  *   // Users deleted
  685.  * });
  686.  *
  687.  * @param   {Function}  [cb]        Callback function
  688.  *
  689.  * @return  {Promise|undefined}
  690.  */
  691. utils.wrapPropertyMethod(ManagementClient, 'deleteAllUsers', 'users.deleteAll');
  694. /**
  695.  * Delete a user by its id.
  696.  *
  697.  * @method    deleteUser
  698.  * @memberOf  module:management.ManagementClient.prototype
  699.  *
  700.  * @example
  701.  * management.deleteUser({ id: USER_ID }, function (err) {
  702.  *   if (err) {
  703.  *     // Handle error.
  704.  *   }
  705.  *
  706.  *   // User deleted.
  707.  * });
  708.  *
  709.  * @param   {Object}    params      The user data object..
  710.  * @param   {String}    params.id   The user id.
  711.  * @param   {Function}  [cb]        Callback function
  712.  *
  713.  * @return  {Promise|undefined}
  714.  */
  715. utils.wrapPropertyMethod(ManagementClient, 'deleteUser', 'users.delete');
  718. /**
  719.  * Create a new user.
  720.  *
  721.  * @method    createUser
  722.  * @memberOf  module:management.ManagementClient.prototype
  723.  *
  724.  * @example
  725.  * management.createUser(data, function (err) {
  726.  *   if (err) {
  727.  *     // Handle error.
  728.  *   }
  729.  *
  730.  *   // User created.
  731.  * });
  732.  *
  733.  * @param   {Object}    data    User data.
  734.  * @param   {Function}  [cb]    Callback function.
  735.  *
  736.  * @return  {Promise|undefined}
  737.  */
  738. utils.wrapPropertyMethod(ManagementClient, 'createUser', 'users.create');
  741. /**
  742.  * Update a user by its id.
  743.  *
  744.  * @method    updateUser
  745.  * @memberOf  module:management.ManagementClient.prototype
  746.  *
  747.  * @example
  748.  * var params = { id: USER_ID };
  749.  *
  750.  * management.updateUser(params, data, function (err, user) {
  751.  *   if (err) {
  752.  *     // Handle error.
  753.  *   }
  754.  *
  755.  *   // Updated user.
  756.  *   console.log(user);
  757.  * });
  758.  *
  759.  * @param   {Object}    params      The user parameters.
  760.  * @param   {String}    params.id   The user id.
  761.  * @param   {Object}    data        New user data.
  762.  * @param   {Function}  [cb]        Callback function
  763.  *
  764.  * @return  {Promise|undefined}
  765.  */
  766. utils.wrapPropertyMethod(ManagementClient, 'updateUser', 'users.update');
  769. /**
  770.  * Update the user metadata for a user.
  771.  *
  772.  * @method    updateUserMetadata
  773.  * @memberOf  module:management.ManagementClient.prototype
  774.  *
  775.  * @example
  776.  * var params = { id: USER_ID };
  777.  * var metadata = {
  778.  *   address: '123th Node.js Street'
  779.  * };
  780.  *
  781.  * management.updateUserMetadata(params, metadata, function (err, user) {
  782.  *   if (err) {
  783.  *     // Handle error.
  784.  *   }
  785.  *
  786.  *   // Updated user.
  787.  *   console.log(user);
  788.  * });
  789.  *
  790.  * @param   {Object}    params      The user data object..
  791.  * @param   {String}    params.id   The user id.
  792.  * @param   {Object}    metadata    New user metadata.
  793.  * @param   {Function}  [cb]        Callback function
  794.  *
  795.  * @return  {Promise|undefined}
  796.  */
  797. utils.wrapPropertyMethod(ManagementClient, 'updateUserMetadata', 'users.updateUserMetadata');
  800. /**
  801.  * Update the app metadata for a user.
  802.  *
  803.  * @method    updateAppMetadata
  804.  * @memberOf  module:management.ManagementClient.prototype
  805.  *
  806.  * @example
  807.  * var params = { id: USER_ID };
  808.  * var metadata = {
  809.  *   foo: 'bar'
  810.  * };
  811.  *
  812.  * management.updateAppMetadata(params, metadata, function (err, user) {
  813.  *   if (err) {
  814.  *     // Handle error.
  815.  *   }
  816.  *
  817.  *   // Updated user.
  818.  *   console.log(user);
  819.  * });
  820.  *
  821.  * @param   {Object}    params      The user data object..
  822.  * @param   {String}    params.id   The user id.
  823.  * @param   {Object}    metadata    New app metadata.
  824.  * @param   {Function}  [cb]        Callback function
  825.  *
  826.  * @return  {Promise|undefined}
  827.  */
  828. utils.wrapPropertyMethod(ManagementClient, 'updateAppMetadata', 'users.updateAppMetadata');
  831. /**
  832.  * Delete a multifactor provider for a user.
  833.  *
  834.  * @method    deleteUserMultifactor
  835.  * @memberOf  module:management.ManagementClient.prototype
  836.  *
  837.  * @example
  838.  * var params = { id: USER_ID, provider: MULTIFACTOR_PROVIDER };
  839.  *
  840.  * management.deleteUserMultifcator(params, function (err, user) {
  841.  *   if (err) {
  842.  *     // Handle error.
  843.  *   }
  844.  *
  845.  *   // Users accounts unlinked.
  846.  * });
  847.  *
  848.  * @param   {Object}    params            Data object.
  849.  * @param   {String}    params.id         The user id.
  850.  * @param   {String}    params.provider   Multifactor provider.
  851.  * @param   {Function}  [cb]              Callback function
  852.  *
  853.  * @return  {Promise|undefined}
  854.  */
  855. utils.wrapPropertyMethod(ManagementClient, 'deleteUserMultifcator', 'users.deleteMultifactorProvider');
  858. /**
  859.  * Unlink the given accounts.
  860.  *
  861.  * @method    unlinkUsers
  862.  * @memberOf  module:management.ManagementClient.prototype
  863.  *
  864.  * @example
  865.  * var params = { id: USER_ID, provider: 'auht0', user_id: OTHER_USER_ID };
  866.  *
  867.  * management.unlinkUsers(params, function (err, user) {
  868.  *   if (err) {
  869.  *     // Handle error.
  870.  *   }
  871.  *
  872.  *   // Users accounts unlinked.
  873.  * });
  874.  *
  875.  * @param   {Object}    params            Linked users data.
  876.  * @param   {String}    params.id         Primary user ID.
  877.  * @param   {String}    params.provider   Identity provider in use.
  878.  * @param   {String}    params.user_id    Secondary user ID.
  879.  * @param   {Function}  [cb]              Callback function.
  880.  *
  881.  * @return {Promise|undefined}
  882.  */
  883. utils.wrapPropertyMethod(ManagementClient, 'unlinkUsers', 'users.unlink');
  886. /**
  887.  * Link the user with another account.
  888.  *
  889.  * @method    linkUsers
  890.  * @memberOf  module:management.ManagementClient.prototype
  891.  *
  892.  * @example
  893.  * var params = { id: USER_ID };
  894.  * var data = {
  895.  *   user_id: 'OTHER_USER_ID',
  896.  *   connection_id: 'CONNECTION_ID'
  897.  * };
  898.  *
  899.  * management.linkUsers(params, data, function (err, user) {
  900.  *   if (err) {
  901.  *     // Handle error.
  902.  *   }
  903.  *
  904.  *   // Users linked.
  905.  * });
  906.  *
  907.  * @param   {String}    userId                ID of the primary user.
  908.  * @param   {Object}    params                Secondary user data.
  909.  * @param   {String}    params.user_id        ID of the user to be linked.
  910.  * @param   {String}    params.connection_id  ID of the connection to be used.
  911.  * @param   {Function}  [cb]                  Callback function.
  912.  *
  913.  * @return  {Promise|undefined}
  914.  */
  915. utils.wrapPropertyMethod(ManagementClient, 'linkUsers', 'users.link');
  918. /**
  919.  * Get all blacklisted tokens.
  920.  *
  921.  * @method    getBlacklistedTokens
  922.  * @memberOf  module:management.ManagementClient.prototype
  923.  *
  924.  * @example
  925.  * management.getBlacklistedTokens(function (err, tokens) {
  926.  *   console.log(tokens.length);
  927.  * });
  928.  *
  929.  * @param   {Function}  [cb]    Callback function.
  930.  *
  931.  * @return  {Promise|undefined}
  932.  */
  933. utils.wrapPropertyMethod(ManagementClient, 'getBlacklistedTokens', 'blacklistedTokens.getAll');
  936. /**
  937.  * Blacklist a new token.
  938.  *
  939.  * @method    blacklistToken
  940.  * @memberOf  module:management.ManagementClient.prototype
  941.  *
  942.  * @example
  943.  * var token = {
  944.  *  aud: 'aud',
  945.  *  jti: 'jti'
  946.  * };
  947.  *
  948.  * management.blacklistToken(token, function (err) {
  949.  *   if (err) {
  950.  *     // Handle error.
  951.  *   }
  952.  *
  953.  *   // Token blacklisted.
  954.  * });
  955.  *
  956.  * @param   {Object}    token      Token data.
  957.  * @param   {String}    token.aud  Audience (your app client ID).
  958.  * @param   {String}    token.jti  The JWT ID claim.
  959.  * @param   {Function}  [cb]       Callback function.
  960.  *
  961.  * @return  {Promise|undefined}
  962.  */
  963. utils.wrapPropertyMethod(ManagementClient, 'blacklistToken', 'blacklistedTokens.add');
  966. /**
  967.  * Get the email provider.
  968.  *
  969.  * @method    getEmailProvider
  970.  * @memberOf  module:management.ManagementClient.prototype
  971.  *
  972.  * @example
  973.  * management.getEmailProvider(function (err, provider) {
  974.  *   console.log(provider.length);
  975.  * });
  976.  *
  977.  * @param   {Function}  [cb]    Callback function.
  978.  *
  979.  * @return  {Promise|undefined}
  980.  */
  981. utils.wrapPropertyMethod(ManagementClient, 'getEmailProvider', 'emailProvider.get');
  984. /**
  985.  * Configure the email provider.
  986.  *
  987.  * @method    configureEmailProvider
  988.  * @memberOf  module:management.ManagementClient.prototype
  989.  *
  990.  * @example
  991.  * management.configureEmailProvider(data, function (err) {
  992.  *   if (err) {
  993.  *     // Handle error.
  994.  *   }
  995.  *
  996.  *   // Email provider configured.
  997.  * });
  998.  *
  999.  * @param   {Object}    data     The email provider data object.
  1000.  * @param   {Function}  [cb]     Callback function.
  1001.  *
  1002.  * @return  {Promise|undefined}
  1003.  */
  1004. utils.wrapPropertyMethod(ManagementClient, 'configureEmailProvider', 'emailProvider.configure');
  1007. /**
  1008.  * Delete email provider.
  1009.  *
  1010.  * @method    deleteEmailProvider
  1011.  * @memberOf  module:management.ManagementClient.prototype
  1012.  *
  1013.  * @example
  1014.  * management.deleteEmailProvider(function (err) {
  1015.  *   if (err) {
  1016.  *     // Handle error.
  1017.  *   }
  1018.  *
  1019.  *   // Email provider deleted.
  1020.  * });
  1021.  *
  1022.  * @param   {Function}  [cb]    Callback function.
  1023.  *
  1024.  * @return  {Promise|undefined}
  1025.  */
  1026. utils.wrapPropertyMethod(ManagementClient, 'deleteEmailProvider', 'emailProvider.delete');
  1029. /**
  1030.  * Update the email provider.
  1031.  *
  1032.  * @method    updateEmailProvider
  1033.  * @memberOf  module:management.ManagementClient.prototype
  1034.  *
  1035.  * @example
  1036.  * management.updateEmailProvider(data, function (err, provider) {
  1037.  *   if (err) {
  1038.  *     // Handle error.
  1039.  *   }
  1040.  *
  1041.  *   // Updated email provider.
  1042.  *   console.log(provider);
  1043.  * });
  1044.  *
  1045.  * @param   {Object}    data              Updated email provider data.
  1046.  * @param   {Function}  [cb]              Callback function.
  1047.  *
  1048.  * @return    {Promise|undefined}
  1049.  */
  1050. utils.wrapPropertyMethod(ManagementClient, 'updateEmailProvider', 'emailProvider.update');
  1053. /**
  1054.  * Get a the active users count.
  1055.  *
  1056.  * @method    getActiveUsersCount
  1057.  * @memberOf  module:management.ManagementClient.prototype
  1058.  *
  1059.  * @example
  1060.  * management.getActiveUsersCount(function (err, usersCount) {
  1061.  *   if (err) {
  1062.  *     // Handle error.
  1063.  *   }
  1064.  *
  1065.  *   console.log(usersCount);
  1066.  * });
  1067.  *
  1068.  * @param   {Function}  [cb]  Callback function.
  1069.  *
  1070.  * @return  {Promise|undefined}
  1071.  */
  1072. utils.wrapPropertyMethod(ManagementClient, 'getActiveUsersCount', 'stats.getActiveUsersCount');
  1075. /**
  1076.  * Get the daily stats.
  1077.  *
  1078.  * @method    getDailyStats
  1079.  * @memberOf  module:management.ManagementClient.prototype
  1080.  *
  1081.  * @example
  1082.  * var params = {
  1083.  *   from: '{YYYYMMDD}',  // First day included in the stats.
  1084.  *   to: '{YYYYMMDD}'  // Last day included in the stats.
  1085.  * };
  1086.  *
  1087.  * management.getDaily(params, function (err, stats) {
  1088.  *   if (err) {
  1089.  *     // Handle error.
  1090.  *   }
  1091.  *
  1092.  *   console.log(stats);
  1093.  * });
  1094.  *
  1095.  * @param   {Object}    params        Stats parameters.
  1096.  * @param   {String}    params.from   The first day in YYYYMMDD format.
  1097.  * @param   {String}    params.to     The last day in YYYYMMDD format.
  1098.  * @param   {Function}  [cb]          Callback function.
  1099.  *
  1100.  * @return  {Promise|undefined}
  1101.  */
  1102. utils.wrapPropertyMethod(ManagementClient, 'getDailyStats', 'stats.getDaily');
  1105. /**
  1106.  * Get the tenant settings..
  1107.  *
  1108.  * @method    getTenantSettings
  1109.  * @memberOf  module:management.ManagementClient.prototype
  1110.  *
  1111.  * @example
  1112.  * management.getSettings(function (err, settings) {
  1113.  *   if (err) {
  1114.  *     // Handle error.
  1115.  *   }
  1116.  *
  1117.  *   console.log(settings);
  1118.  * });
  1119.  *
  1120.  * @param   {Function}  [cb]  Callback function.
  1121.  *
  1122.  * @return  {Promise|undefined}
  1123.  */
  1124. utils.wrapPropertyMethod(ManagementClient, 'getTenantSettings', 'tenant.getSettings');
  1127. /**
  1128.  * Update the tenant settings.
  1129.  *
  1130.  * @method    updateTenantSettings
  1131.  * @memberOf  module:management.ManagementClient.prototype
  1132.  *
  1133.  * @example
  1134.  * management.updateTenantSettings(data, function (err) {
  1135.  *   if (err) {
  1136.  *     // Handle error.
  1137.  *   }
  1138.  * });
  1139.  *
  1140.  * @param   {Object}    data  The new tenant settings.
  1141.  * @param   {Function}  [cb]  Callback function.
  1142.  *
  1143.  * @return  {Promise|undefined}
  1144.  */
  1145. utils.wrapPropertyMethod(ManagementClient, 'updateTenantSettings', 'tenant.updateSettings');
  1148. /**
  1149.  * Get a job by its ID.
  1150.  *
  1151.  * @method    getJob
  1152.  * @memberOf  module:management.ManagementClient.prototype
  1153.  *
  1154.  * @example
  1155.  * var params = {
  1156.  *   id: '{JOB_ID}'
  1157.  * };
  1158.  *
  1159.  * management.getJob(params, function (err, job) {
  1160.  *   if (err) {
  1161.  *     // Handle error.
  1162.  *   }
  1163.  *
  1164.  *   // Retrieved job.
  1165.  *   console.log(job);
  1166.  * });
  1167.  *
  1168.  * @param   {Object}    params        Job parameters.
  1169.  * @param   {String}    params.id     Job ID.
  1170.  * @param   {Function}  [cb]          Callback function.
  1171.  *
  1172.  * @return  {Promise|undefined}
  1173.  */
  1174. utils.wrapPropertyMethod(ManagementClient, 'getJob', 'jobs.get');
  1177. /**
  1178.  * Given a path to a file and a connection id, create a new job that imports the
  1179.  * users contained in the file and associate them with the given connection.
  1180.  *
  1181.  * @method    importUsers
  1182.  * @memberOf  module:management.ManagementClient.prototype
  1183.  *
  1184.  * @example
  1185.  * var params = {
  1186.  *   connection_id: '{CONNECTION_ID}',
  1187.  *   users: '{PATH_TO_USERS_FILE}'
  1188.  * };
  1189.  *
  1190.  * management.get(params, function (err) {
  1191.  *   if (err) {
  1192.  *     // Handle error.
  1193.  *   }
  1194.  * });
  1195.  *
  1196.  * @param   {Object}    data                Users import data.
  1197.  * @param   {String}    data.connectionId   Connection for the users insertion.
  1198.  * @param   {String}    data.users          Path to the users data file.
  1199.  * @param   {Function}  [cb]                Callback function.
  1200.  *
  1201.  * @return  {Promise|undefined}
  1202.  */
  1203. utils.wrapPropertyMethod(ManagementClient, 'importUsers', 'jobs.importUsers');
  1206. /**
  1207.  * Send a verification email to a user.
  1208.  *
  1209.  * @method    sendEmailVerification
  1210.  * @memberOf  module:management.ManagementClient.prototype
  1211.  *
  1212.  * @example
  1213.  * var params = {
  1214.  * 	user_id: '{USER_ID}'
  1215.  * };
  1216.  *
  1217.  * management.sendEmailVerification(function (err) {
  1218.  *   if (err) {
  1219.  *     // Handle error.
  1220.  *   }
  1221.  * });
  1222.  *
  1223.  * @param   {Object}    data          User data object.
  1224.  * @param   {String}    data.user_id  ID of the user to be verified.
  1225.  * @param   {Function}  [cb]          Callback function.
  1226.  *
  1227.  * @return  {Promise|undefined}
  1228.  */
  1229. utils.wrapPropertyMethod(ManagementClient, 'sendEmailVerification', 'jobs.verifyEmail');
  1232. /**
  1233.  * Create a new password change ticket.
  1234.  *
  1235.  * @method    createPasswordChangeTicket
  1236.  * @memberOf  module:management.ManagementClient.prototype
  1237.  *
  1238.  * @example
  1239.  * var params = {
  1240.  *   result_url: '{REDIRECT_URL}',  // Redirect after using the ticket.
  1241.  *   user_id: '{USER_ID}',  // Optional.
  1242.  *   email: '{USER_EMAIL}',  // Optional.
  1243.  *   new_password: '{PASSWORD}'
  1244.  * };
  1245.  *
  1246.  * auth0.createPasswordChangeTicket(params, function (err) {
  1247.  *   if (err) {
  1248.  *     // Handle error.
  1249.  *   }
  1250.  * });
  1251.  *
  1252.  * @param   {Function}  [cb]  Callback function.
  1253.  * @return  {Promise}
  1254.  */
  1255. utils.wrapPropertyMethod(ManagementClient, 'createPasswordChangeTicket', 'tickets.changePassword');
  1258. /**
  1259.  * Create an email verification ticket.
  1260.  *
  1261.  * @method    createEmailVerificationTicket
  1262.  * @memberOf  module:management.ManagementClient.prototype
  1263.  *
  1264.  * @example
  1265.  * var data = {
  1266.  *   user_id: '{USER_ID}',
  1267.  *   result_url: '{REDIRECT_URL}' // Optional redirect after the ticket is used.
  1268.  * };
  1269.  *
  1270.  * auth0.createEmailVerificationTicket(data, function (err) {
  1271.  *   if (err) {
  1272.  *     // Handle error.
  1273.  *   }
  1274.  * });
  1275.  *
  1276.  * @param   {Function}  [cb]  Callback function.
  1277.  * @return  {Promise}
  1278.  */
  1279. utils.wrapPropertyMethod(ManagementClient, 'createEmailVerificationTicket', 'tickets.verifyEmail');
  1281. /**
  1282.  * Get an Auth0 log.
  1283.  *
  1284.  * @method    getLog
  1285.  * @memberOf  module:management.ManagementClient.prototype
  1286.  *
  1287.  * @example
  1288.  * management.getLog({ id: EVENT_ID }, function (err, log) {
  1289.  *   if (err) {
  1290.  *     // Handle error.
  1291.  *   }
  1292.  *
  1293.  *   console.log(log);
  1294.  * });
  1295.  *
  1296.  * @param   {Object}    params          Log parameters.
  1297.  * @param   {String}    params.id       Event ID.
  1298.  * @param   {Function}  [cb]            Callback function.
  1299.  *
  1300.  * @return  {Promise|undefined}
  1301.  */
  1302. utils.wrapPropertyMethod(ManagementClient, 'getLog', 'logs.get');
  1304. /**
  1305.  * Get all logs.
  1306.  *
  1307.  * @method    getLogs
  1308.  * @memberOf  module:management.ManagementClient.prototype
  1309.  *
  1310.  * @example
  1311.  * management.getLogs(function (err, logs) {
  1312.  *   console.log(logs.length);
  1313.  * });
  1314.  *
  1315.  * @param   {Object}    data     Log data object.
  1316.  * @param   {Function}  [cb]     Callback function.
  1317.  *
  1318.  * @return  {Promise|undefined}
  1319.  */
  1320. utils.wrapPropertyMethod(ManagementClient, 'getLogs', 'logs.getAll');
  1323. module.exports = ManagementClient;