authenticators/torii.js

import RSVP from 'rsvp';
import { assert, deprecate } from '@ember/debug';
import { isPresent, isEmpty } from '@ember/utils';
import BaseAuthenticator from './base';

deprecate('Ember Simple Auth: The Torii authenticator is deprecated.', false, {
  id: 'ember-simple-auth.authenticators.torii',
  until: '7.0.0',
  for: 'ember-simple-auth',
  since: {
    enabled: '4.2.0'
  }
});

/**
  Authenticator that wraps the
  [Torii library](https://github.com/adopted-ember-addons/torii) and thus allows to connect
  any external authentication provider that torii defines a provider for.

  In order to use this authenticator, __the application needs to have the
  [torii addon](https://github.com/adopted-ember-addons/torii) installed and must inject
  the torii service into the authenticator__:

  ```js
  // app/authenticators/torii.js
  import Torii from 'ember-simple-auth/authenticators/torii';
  import { inject as service } from '@ember/service';

  export default class ToriiAuthenticator extends Torii {
    @service torii;
  }
  ```

  @class ToriiAuthenticator
  @deprecated Implement an authenticator that wraps Torii in application code instead: since 4.2.0
  @extends BaseAuthenticator
  @public
*/
export default BaseAuthenticator.extend({
  _provider: null,

  /**
    Restores the session by calling the torii provider's `fetch` method.

    __Many torii providers do not implement the `fetch` method__. If the
    provider in use does not implement the method simply add it as follows:

    ```js
    // app/torii-providers/facebook.js
    import FacebookOauth2Provider from 'torii/providers/facebook-oauth2';

    export default class FacebookToriiProvider extends FacebookOauth2Provider {
      fetch(data) {
        return data;
      }
    }
    ```

    @memberof ToriiAuthenticator
    @method restore
    @param {Object} data The data to restore the session from
    @return {Ember.RSVP.Promise} A promise that when it resolves results in the session becoming or remaining authenticated
    @public
  */
  restore(data) {
    this._assertToriiIsPresent();

    data = data || {};
    if (!isEmpty(data.provider)) {
      const { provider } = data;

      return this.get('torii').fetch(data.provider, data).then(
        (fetchedData) => {
          this._authenticateWithProvider(provider, fetchedData);
          return Object.assign(data, fetchedData);
        },
        (err) => {
          delete this._provider;
          throw err;
        }
      );
    } else {
      delete this._provider;
      return RSVP.reject();
    }
  },

  /**
    Authenticates the session by opening the specified torii provider. For more
    documentation on torii and its providers abstraction, see the
    [project's README]( https://github.com/adopted-ember-addons/torii), specifically
    the
    [section on providers](https://github.com/adopted-ember-addons/torii).

    @memberof ToriiAuthenticator
    @method authenticate
    @param {String} provider The torii provider to authenticate the session with
    @param {Object} options The options to pass to the torii provider
    @return {Ember.RSVP.Promise} A promise that when it resolves results in the session becoming authenticated
    @public
  */
  authenticate(provider, options) {
    this._assertToriiIsPresent();

    return this.get('torii').open(provider, options || {}).then((data) => {
      this._authenticateWithProvider(provider, data);
      return data;
    });
  },

  /**
    Closes the torii provider. If the provider is successfully closed, this
    method returns a resolving promise, otherwise it will return a rejecting
    promise, thus intercepting session invalidation.

    @memberof ToriiAuthenticator
    @method invalidate
    @return {Ember.RSVP.Promise} A promise that when it resolves results in the session being invalidated
    @public
  */
  invalidate(data) {
    return this.get('torii').close(this._provider, data).then(() => {
      delete this._provider;
    });
  },

  _authenticateWithProvider(provider, data) {
    data.provider = provider;
    this._provider = data.provider;
  },

  _assertToriiIsPresent() {
    const torii = this.get('torii');
    assert('You are trying to use the torii authenticator but torii is not available. Inject torii into the authenticator with "torii: Ember.inject.service()".', isPresent(torii));
  }
});