高度なワークフロー

import { Auth } from 'aws-amplify';

// To derive necessary data from the provider
const {
  token, // the token you get from the provider
  domainOrProviderName, // Either the domain of the provider(e.g. accounts.your-openid-provider.com) or the provider name, for now the library only supports 'google', 'facebook', 'amazon', 'developer'
  expiresIn, // the time in ms which describes how long the token could live
  user, // the user object you defined, e.g. { username, email, phone_number }
  identity_id // Optional, the identity id specified by the provider
} = getFromProvider(); // arbitrary function

async function getCognitoCredentials() {
  try {
    const cred = await Auth.federatedSignIn(
      domainOrProviderName,
      {
        token,
        identity_id, // Optional
        expires_at: expiresIn * 1000 + new Date().getTime() // the expiration timestamp
      },
      user
    );
    console.log(cred);

    const authenticatedUser = await Auth.currentAuthenticatedUser();

    console.log(authenticatedUser);
  } catch (err) {
    console.log(err);
  }
}

import React, { useEffect } from 'react';
import { Auth } from 'aws-amplify';
// To federated sign in from Facebook
const SignInWithFacebook = () => {
  useEffect(() => {
    if (!window.FB) createScript();
  }, []);

  const signIn = () => {
    const fb = window.FB;
    fb.getLoginStatus((response) => {
      if (response.status === 'connected') {
        getAWSCredentials(response.authResponse);
      } else {
        fb.login(
          (response) => {
            if (!response || !response.authResponse) {
              return;
            }
            getAWSCredentials(response.authResponse);
          },
          {
            // the authorized scopes
            scope: 'public_profile,email'
          }
        );
      }
    });
  };

  const getAWSCredentials = (response) => {
    const { accessToken, expiresIn } = response;
    const date = new Date();
    const expires_at = expiresIn * 1000 + date.getTime();
    if (!accessToken) {
      return;
    }

    const fb = window.FB;
    fb.api('/me', { fields: 'name,email' }, (response) => {
      const user = {
        name: response.name,
        email: response.email
      };

      getCognitoCredentials(
        'facebook',
        { token: accessToken, expires_at },
        user
      );
    });
  };

  const getCognitoCredentials = async (providerName, federateOptions, user) => {
    try {
      const credentials = await Auth.federatedSignIn(
        providerName,
        federateOptions,
        user
      );
      console.log(credentials);
    } catch (err) {
      console.log(err);
    }
  };

  const createScript = () => {
    // load the sdk
    window.fbAsyncInit = fbAsyncInit;
    const script = document.createElement('script');
    script.src = 'https://connect.facebook.net/en_US/sdk.js';
    script.async = true;
    script.onload = initFB;
    document.body.appendChild(script);
  };

  const initFB = () => {
    const fb = window.FB;
    console.log('FB SDK initialized');
  };

  const fbAsyncInit = () => {
    // init the fb sdk client
    const fb = window.FB;
    fb.init({
      appId: 'your_facebook_app_id',
      cookie: true,
      xfbml: true,
      version: 'v2.11'
    });
  };

  return (
    <div>
      <button onClick={signIn}>Sign in with Facebook</button>
    </div>
  );
};

import Expo from 'expo';
import React from 'react';
import { Amplify, Auth } from 'aws-amplify';

const App = () => {
  const signIn = async () => {
    const { type, token, expires } =
      await Expo.Facebook.logInWithReadPermissionsAsync(
        'YOUR_FACEBOOK_APP_ID',
        {
          permissions: ['public_profile']
        }
      );
    if (type === 'success') {
      // sign in with federated identity
      try {
        const credentials = await Auth.federatedSignIn(
          'facebook',
          { token, expires_at: expires },
          { name: 'USER_NAME' }
        );
        console.log('get aws credentials', credentials);
      } catch (err) {
        console.log(err);
      }
    }
  };

  // ...

  return (
    <View style={styles.container}>
      <Button title="FBSignIn" onPress={signIn} />
    </View>
  );
};

import { Cache } from 'aws-amplify';

// Run this after the sign-in
const federatedInfo = Cache.getItem('federatedInfo');
const { token } = federatedInfo;

import { Cache } from 'aws-amplify';

// inside an async function
// Run this after the sign-in
const federatedInfo = await Cache.getItem('federatedInfo');
const { token } = federatedInfo;

import { Auth } from 'aws-amplify';

async function refreshToken() {
  // refresh the token here and get the new token info
  // ......

  const data = {
    token, // the token from the provider
    expires_at, // the timestamp for the expiration
    identity_id // optional, the identityId for the credentials
  };

  return data;
}

Auth.configure({
  refreshHandlers: {
    developer: refreshToken // the property could be 'google', 'facebook', 'amazon', 'developer', OpenId domain
  }
});

const { idToken, domain, name, email, phoneNumber } = getFromAuth0(); // get the user credentials and info from auth0
const { exp } = decodeJWTToken(idToken); // Please decode the id token in order to get the expiration time

async function getCognitoCredentials() {
  try {
    const cred = await Auth.federatedSignIn(
      domain, // The Auth0 Domain,
      {
        token: idToken, // The id token from Auth0
        // expires_at means the timestamp when the token provided expires,
        // here you can derive it from the expiresIn parameter provided,
        // then convert its unit from second to millisecond, and add the current timestamp
        expires_at: exp * 1000 // the expiration timestamp
      },
      {
        // the user object, you can put whatever property you get from the Auth0
        // for example:
        name, // the user name
        email, // Optional, the email address
        phoneNumber // Optional, the phone number
      }
    );

    console.log(cred);
  } catch (err) {
    console.log(err);
  }
}

const user = await Auth.currentAuthenticatedUser();
console.log(user);
const creds = await Auth.currentCredentials();
console.log(creds);
// await Auth.currentSession() does not currently support federated identities. Please store the auth0 session info manually(for example, store tokens into the local storage).

async function refreshToken() {
  // refresh the token here and get the new token info
  // ......

  const data = {
    token, // the token from the provider
    expires_at, // the timestamp when the token expires (in milliseconds)
    identity_id // optional, the identityId for the credentials
  };

  return data;
}

Auth.configure({
  refreshHandlers: {
    your_auth0_domain: refreshToken
  }
});

import { Auth } from 'aws-amplify';

async function signIn() {
  try {
    const user = await Auth.signIn({
      username, // Required, the username
      password, // Optional, the password
      validationData // Optional, an object of key-value pairs which can contain any key and will be passed to your Lambda trigger as-is.
    });
    console.log(user);
  } catch (err) {
    console.log(err);
  }
}

Auth.signUp({
  username,
  password,
  attributes: {
    email, // optional
    phone_number // optional - E.164 number convention
    // other custom attributes
  },
  autoSignIn: {
    // optional - enables auto sign in after user is confirmed
    enabled: true,
    validationData // optional
  }
});

import { Auth } from 'aws-amplify';
import Route53 from 'aws-sdk/clients/route53';

async function changeResourceRecordSets() {
  try {
    const credentials = await Auth.currentCredentials();

    const route53 = new Route53({
      apiVersion: '2013-04-01',
      credentials: Auth.essentialCredentials(credentials)
    });

    // more code working with route53 object
    //route53.changeResourceRecordSets();
  } catch (err) {
    console.log(err);
  }
}