@aws-amplify/core 5.8.6-unstable.7762f1a.0 → 6.0.0

package/lib-esm/providers/pinpoint/utils/getEventBuffer.js

@@ -0,0 +1,42 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PinpointEventBuffer } from './PinpointEventBuffer';
+import { BUFFER_SIZE, FLUSH_INTERVAL, FLUSH_SIZE, RESEND_LIMIT } from './constants';
+// Map of buffers by region -> appId
+const eventBufferMap = {};
+/**
+ * Returns a PinpointEventBuffer instance for the specified region & app ID, creating one if it does not yet exist.
+ *
+ * @internal
+ */
+export const getEventBuffer = ({ appId, bufferSize = BUFFER_SIZE, credentials, flushInterval = FLUSH_INTERVAL, flushSize = FLUSH_SIZE, identityId, region, resendLimit = RESEND_LIMIT, userAgentValue }) => {
+    if (eventBufferMap[region]?.[appId]) {
+        const buffer = eventBufferMap[region][appId];
+        /*
+        If the identity has changed flush out the buffer and create a new instance. The old instance will be garbage
+        collected.
+        */
+        if (buffer.identityHasChanged(identityId)) {
+            buffer.flush();
+        }
+        else {
+            return buffer;
+        }
+    }
+    const buffer = new PinpointEventBuffer({
+        appId,
+        bufferSize,
+        credentials,
+        flushInterval,
+        flushSize,
+        identityId,
+        region,
+        resendLimit,
+        userAgentValue
+    });
+    if (!eventBufferMap[region]) {
+        eventBufferMap[region] = {};
+    }
+    eventBufferMap[region][appId] = buffer;
+    return buffer;
+};

package/lib-esm/providers/pinpoint/utils/index.d.ts

@@ -0,0 +1,4 @@
+export { cacheEndpointId } from './cacheEndpointId';
+export { getCacheKey } from './getCacheKey';
+export { getEndpointId } from './getEndpointId';
+export { resolveEndpointId } from './resolveEndpointId';

package/lib-esm/providers/pinpoint/utils/index.js

@@ -0,0 +1,6 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { cacheEndpointId } from './cacheEndpointId';
+export { getCacheKey } from './getCacheKey';
+export { getEndpointId } from './getEndpointId';
+export { resolveEndpointId } from './resolveEndpointId';

package/lib-esm/providers/pinpoint/utils/isAppInForeground.d.ts

@@ -0,0 +1 @@
+export declare const isAppInForeground: () => boolean;

package/lib-esm/providers/pinpoint/utils/isAppInForeground.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export const isAppInForeground = () => true;

package/lib-esm/providers/pinpoint/utils/isAppInForeground.native.d.ts

@@ -0,0 +1 @@
+export declare const isAppInForeground: () => boolean;

package/lib-esm/providers/pinpoint/utils/isAppInForeground.native.js

@@ -0,0 +1,5 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// @ts-ignore: missing type definition
+import { AppState } from 'react-native';
+export const isAppInForeground = () => AppState.currentState === 'active';

package/lib-esm/providers/pinpoint/utils/resolveEndpointId.d.ts

@@ -0,0 +1,8 @@
+import { PinpointUpdateEndpointInput } from '../types';
+/**
+ * Resolves an endpoint id from cache or prepare via updateEndpoint if one does not already exist,
+ * which will generate and cache an endpoint id between calls.
+ *
+ * @internal
+ */
+export declare const resolveEndpointId: ({ address, appId, category, channelType, credentials, identityId, region, userAgentValue, }: PinpointUpdateEndpointInput) => Promise<string>;

package/lib-esm/providers/pinpoint/utils/resolveEndpointId.js

@@ -0,0 +1,30 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { assert } from '../../../errors';
+import { AmplifyErrorCode } from '../../../types';
+import { updateEndpoint } from '../apis';
+import { getEndpointId } from './getEndpointId';
+/**
+ * Resolves an endpoint id from cache or prepare via updateEndpoint if one does not already exist,
+ * which will generate and cache an endpoint id between calls.
+ *
+ * @internal
+ */
+export const resolveEndpointId = async ({ address, appId, category, channelType, credentials, identityId, region, userAgentValue, }) => {
+    let endpointId = await getEndpointId(appId, category);
+    if (!endpointId) {
+        await updateEndpoint({
+            address,
+            appId,
+            category,
+            channelType,
+            credentials,
+            identityId,
+            region,
+            userAgentValue,
+        });
+        endpointId = await getEndpointId(appId, category);
+    }
+    assert(!!endpointId, AmplifyErrorCode.NoEndpointId);
+    return endpointId;
+};

package/lib-esm/server.d.ts

@@ -0,0 +1 @@
+export { fetchAuthSession } from './singleton/apis/server/fetchAuthSession';

package/lib-esm/server.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { fetchAuthSession } from './singleton/apis/server/fetchAuthSession';

package/lib-esm/singleton/API/types.d.ts

@@ -0,0 +1,73 @@
+import { Headers } from '../../clients';
+export type LibraryAPIOptions = {
+    GraphQL?: {
+        headers?: (options: {
+            query: string;
+            variables?: Record<string, DocumentType>;
+        }) => Promise<Headers>;
+        withCredentials?: boolean;
+    };
+    REST?: {
+        headers?: (options: {
+            apiName: string;
+        }) => Promise<Headers>;
+    };
+};
+type APIGraphQLConfig = {
+    /**
+     * Required GraphQL endpoint, must be a valid URL string.
+     */
+    endpoint: string;
+    /**
+     * Optional region string used to sign the request. Required only if the auth mode is 'iam'.
+     */
+    region?: string;
+    /**
+     * Optional API key string. Required only if the auth mode is 'apiKey'.
+     */
+    apiKey?: string;
+    /**
+     * Custom domain endpoint for GraphQL API.
+     */
+    customEndpoint?: string;
+    /**
+     * Optional region string used to sign the request to `customEndpoint`. Effective only if `customEndpoint` is
+     * specified, and the auth mode is 'iam'.
+     */
+    customEndpointRegion?: string;
+    /**
+     * Default auth mode for all the API calls to given service.
+     */
+    defaultAuthMode: GraphQLAuthMode;
+};
+type APIRestConfig = {
+    /**
+     * Required REST endpoint, must be a valid URL string.
+     */
+    endpoint: string;
+    /**
+     * Optional region string used to sign the request with IAM credentials. If Omitted, region will be extracted from
+     * the endpoint.
+     *
+     * @default 'us-east-1'
+     */
+    region?: string;
+    /**
+     * Optional service name string to sign the request with IAM credentials.
+     *
+     * @default 'execute-api'
+     */
+    service?: string;
+};
+export type APIConfig = {
+    REST?: Record<string, APIRestConfig>;
+    GraphQL?: APIGraphQLConfig;
+};
+export type GraphQLAuthMode = 'apiKey' | 'oidc' | 'userPool' | 'iam' | 'lambda' | 'none';
+/**
+ * Type representing a plain JavaScript object that can be serialized to JSON.
+ */
+export type DocumentType = null | boolean | number | string | DocumentType[] | {
+    [prop: string]: DocumentType;
+};
+export {};

package/lib-esm/singleton/Amplify.d.ts

@@ -0,0 +1,40 @@
+import { AuthClass } from './Auth';
+import { LegacyConfig, LibraryOptions, ResourcesConfig } from './types';
+export declare class AmplifyClass {
+    resourcesConfig: ResourcesConfig;
+    libraryOptions: LibraryOptions;
+    /**
+     * Cross-category Auth utilities.
+     *
+     * @internal
+     */
+    readonly Auth: AuthClass;
+    constructor();
+    /**
+     * Configures Amplify for use with your back-end resources.
+     *
+     * @remarks
+     * This API does not perform any merging of either `resourcesConfig` or `libraryOptions`. The most recently
+     * provided values will be used after configuration.
+     *
+     * @remarks
+     * `configure` can be used to specify additional library options where available for supported categories.
+     *
+     * @param resourceConfig - Back-end resource configuration. Typically provided via the `aws-exports.js` file.
+     * @param libraryOptions - Additional options for customizing the behavior of the library.
+     */
+    configure(resourcesConfig: ResourcesConfig | LegacyConfig, libraryOptions?: LibraryOptions): void;
+    /**
+     * Provides access to the current back-end resource configuration for the Library.
+     *
+     * @returns Returns the immutable back-end resource configuration.
+     */
+    getConfig(): Readonly<ResourcesConfig>;
+}
+/**
+ * The `Amplify` utility is used to configure the library.
+ *
+ * @remarks
+ * `Amplify` is responsible for orchestrating cross-category communication within the library.
+ */
+export declare const Amplify: AmplifyClass;

package/lib-esm/singleton/Amplify.js

@@ -0,0 +1,61 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AuthClass } from './Auth';
+import { Hub, AMPLIFY_SYMBOL } from '../Hub';
+import { parseAWSExports } from '../parseAWSExports';
+import { deepFreeze } from '../utils';
+export class AmplifyClass {
+    constructor() {
+        this.resourcesConfig = {};
+        this.libraryOptions = {};
+        this.Auth = new AuthClass();
+    }
+    /**
+     * Configures Amplify for use with your back-end resources.
+     *
+     * @remarks
+     * This API does not perform any merging of either `resourcesConfig` or `libraryOptions`. The most recently
+     * provided values will be used after configuration.
+     *
+     * @remarks
+     * `configure` can be used to specify additional library options where available for supported categories.
+     *
+     * @param resourceConfig - Back-end resource configuration. Typically provided via the `aws-exports.js` file.
+     * @param libraryOptions - Additional options for customizing the behavior of the library.
+     */
+    configure(resourcesConfig, libraryOptions) {
+        let resolvedResourceConfig;
+        if (Object.keys(resourcesConfig).some(key => key.startsWith('aws_'))) {
+            resolvedResourceConfig = parseAWSExports(resourcesConfig);
+        }
+        else {
+            resolvedResourceConfig = resourcesConfig;
+        }
+        this.resourcesConfig = resolvedResourceConfig;
+        if (libraryOptions) {
+            this.libraryOptions = libraryOptions;
+        }
+        // Make resource config immutable
+        this.resourcesConfig = deepFreeze(this.resourcesConfig);
+        this.Auth.configure(this.resourcesConfig.Auth, this.libraryOptions.Auth);
+        Hub.dispatch('core', {
+            event: 'configure',
+            data: resourcesConfig,
+        }, 'Configure', AMPLIFY_SYMBOL);
+    }
+    /**
+     * Provides access to the current back-end resource configuration for the Library.
+     *
+     * @returns Returns the immutable back-end resource configuration.
+     */
+    getConfig() {
+        return this.resourcesConfig;
+    }
+}
+/**
+ * The `Amplify` utility is used to configure the library.
+ *
+ * @remarks
+ * `Amplify` is responsible for orchestrating cross-category communication within the library.
+ */
+export const Amplify = new AmplifyClass();

package/lib-esm/singleton/Analytics/types.d.ts

@@ -0,0 +1,9 @@
+import { PinpointProviderConfig } from '../../providers/pinpoint/types';
+import { KinesisProviderConfig } from '../../providers/kinesis/types';
+import { KinesisFirehoseProviderConfig } from '../../providers/kinesis-firehose/types';
+import { PersonalizeProviderConfig } from '../../providers/personalize/types';
+type AtLeastOne<T, U = {
+    [K in keyof T]: Pick<T, K>;
+}> = Partial<T> & U[keyof U];
+export type AnalyticsConfig = AtLeastOne<PinpointProviderConfig & KinesisProviderConfig & KinesisFirehoseProviderConfig & PersonalizeProviderConfig>;
+export {};

package/lib-esm/singleton/Analytics/types.js

@@ -0,0 +1,3 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export {};

package/lib-esm/singleton/Auth/index.d.ts

@@ -0,0 +1,24 @@
+import { AuthConfig, AuthSession, AuthTokens, FetchAuthSessionOptions, LibraryAuthOptions } from './types';
+export declare function isTokenExpired({ expiresAt, clockDrift, }: {
+    expiresAt: number;
+    clockDrift: number;
+}): boolean;
+export declare class AuthClass {
+    private authConfig?;
+    private authOptions?;
+    constructor();
+    /**
+     * Configure Auth category
+     *
+     * @internal
+     *
+     * @param authResourcesConfig - Resources configurations required by Auth providers.
+     * @param authOptions - Client options used by library
+     *
+     * @returns void
+     */
+    configure(authResourcesConfig: AuthConfig, authOptions?: LibraryAuthOptions): void;
+    fetchAuthSession(options?: FetchAuthSessionOptions): Promise<AuthSession>;
+    clearCredentials(): Promise<void>;
+    getTokens(options: FetchAuthSessionOptions): Promise<AuthTokens | undefined>;
+}

package/lib-esm/singleton/Auth/index.js

@@ -0,0 +1,62 @@
+export function isTokenExpired({ expiresAt, clockDrift, }) {
+    const currentTime = Date.now();
+    return currentTime + clockDrift > expiresAt;
+}
+export class AuthClass {
+    constructor() { }
+    /**
+     * Configure Auth category
+     *
+     * @internal
+     *
+     * @param authResourcesConfig - Resources configurations required by Auth providers.
+     * @param authOptions - Client options used by library
+     *
+     * @returns void
+     */
+    configure(authResourcesConfig, authOptions) {
+        this.authConfig = authResourcesConfig;
+        this.authOptions = authOptions;
+    }
+    async fetchAuthSession(options = {}) {
+        let tokens;
+        let credentialsAndIdentityId;
+        let userSub;
+        // Get tokens will throw if session cannot be refreshed (network or service error) or return null if not available
+        tokens = await this.getTokens(options);
+        if (tokens) {
+            userSub = tokens.accessToken?.payload?.sub;
+            // getCredentialsAndIdentityId will throw if cannot get credentials (network or service error)
+            credentialsAndIdentityId =
+                await this.authOptions?.credentialsProvider?.getCredentialsAndIdentityId({
+                    authConfig: this.authConfig,
+                    tokens,
+                    authenticated: true,
+                    forceRefresh: options.forceRefresh,
+                });
+        }
+        else {
+            // getCredentialsAndIdentityId will throw if cannot get credentials (network or service error)
+            credentialsAndIdentityId =
+                await this.authOptions?.credentialsProvider?.getCredentialsAndIdentityId({
+                    authConfig: this.authConfig,
+                    authenticated: false,
+                    forceRefresh: options.forceRefresh,
+                });
+        }
+        return {
+            tokens,
+            credentials: credentialsAndIdentityId?.credentials,
+            identityId: credentialsAndIdentityId?.identityId,
+            userSub,
+        };
+    }
+    async clearCredentials() {
+        if (this.authOptions?.credentialsProvider) {
+            return await this.authOptions.credentialsProvider.clearCredentialsAndIdentityId();
+        }
+    }
+    async getTokens(options) {
+        return ((await this.authOptions?.tokenProvider?.getTokens(options)) ?? undefined);
+    }
+}

package/lib-esm/singleton/Auth/types.d.ts

@@ -0,0 +1,155 @@
+interface JwtPayloadStandardFields {
+    exp?: number;
+    iss?: string;
+    aud?: string | string[];
+    nbf?: number;
+    iat?: number;
+    scope?: string;
+    jti?: string;
+    sub?: string;
+}
+/** JSON type */
+type Json = null | string | number | boolean | Json[] | JsonObject;
+/** JSON Object type */
+type JsonObject = {
+    [name: string]: Json;
+};
+export type JwtPayload = JwtPayloadStandardFields & JsonObject;
+export type JWT = {
+    payload: JwtPayload;
+    toString: () => string;
+};
+export type JWTCreator = (stringJWT: string) => JWT;
+export type AuthSession = {
+    tokens?: AuthTokens;
+    credentials?: AWSCredentials;
+    identityId?: string;
+    userSub?: string;
+};
+export type LibraryAuthOptions = {
+    tokenProvider?: TokenProvider;
+    credentialsProvider?: AWSCredentialsAndIdentityIdProvider;
+};
+export type Identity = {
+    id: string;
+    type: 'guest' | 'primary';
+};
+export interface AWSCredentialsAndIdentityIdProvider {
+    getCredentialsAndIdentityId: (getCredentialsOptions: GetCredentialsOptions) => Promise<AWSCredentialsAndIdentityId | undefined>;
+    clearCredentialsAndIdentityId: () => void;
+}
+export type TokenProvider = {
+    getTokens: ({ forceRefresh, }?: {
+        forceRefresh?: boolean;
+    }) => Promise<AuthTokens | null>;
+};
+export type FetchAuthSessionOptions = {
+    forceRefresh?: boolean;
+};
+export type AuthTokens = {
+    idToken?: JWT;
+    accessToken: JWT;
+};
+export type AuthStandardAttributeKey = 'address' | 'birthdate' | 'email_verified' | 'family_name' | 'gender' | 'given_name' | 'locale' | 'middle_name' | 'name' | 'nickname' | 'phone_number_verified' | 'picture' | 'preferred_username' | 'profile' | 'sub' | 'updated_at' | 'website' | 'zoneinfo' | AuthVerifiableAttributeKey;
+export type AuthVerifiableAttributeKey = 'email' | 'phone_number';
+export type AuthConfigUserAttributes = Partial<Record<AuthStandardAttributeKey, {
+    required: boolean;
+}>>;
+export type AuthConfig = StrictUnion<AuthIdentityPoolConfig | AuthUserPoolConfig | AuthUserPoolAndIdentityPoolConfig>;
+type UnionKeys<T> = T extends T ? keyof T : never;
+type StrictUnionHelper<T, TAll> = T extends any ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;
+export type StrictUnion<T> = StrictUnionHelper<T, T>;
+export type AuthIdentityPoolConfig = {
+    Cognito: CognitoIdentityPoolConfig & {
+        userPoolClientId?: never;
+        userPoolId?: never;
+        userPoolEndpoint?: never;
+        loginWith?: never;
+        signUpVerificationMethod?: never;
+        userAttributes?: never;
+        mfa?: never;
+        passwordFormat?: never;
+    };
+};
+export type CognitoIdentityPoolConfig = {
+    identityPoolId: string;
+    allowGuestAccess?: boolean;
+};
+export type AuthUserPoolConfig = {
+    Cognito: CognitoUserPoolConfig & {
+        identityPoolId?: never;
+        allowGuestAccess?: never;
+    };
+};
+export type CognitoUserPoolConfig = {
+    userPoolClientId: string;
+    userPoolId: string;
+    userPoolEndpoint?: string;
+    signUpVerificationMethod?: 'code' | 'link';
+    loginWith?: {
+        oauth?: OAuthConfig;
+        username?: boolean;
+        email?: boolean;
+        phone?: boolean;
+    };
+    userAttributes?: AuthConfigUserAttributes;
+    mfa?: {
+        status?: 'on' | 'off' | 'optional';
+        totpEnabled?: boolean;
+        smsEnabled?: boolean;
+    };
+    passwordFormat?: {
+        minLength?: number;
+        requireLowercase?: boolean;
+        requireUppercase?: boolean;
+        requireNumbers?: boolean;
+        requireSpecialCharacters?: boolean;
+    };
+};
+export type OAuthConfig = {
+    domain: string;
+    scopes: Array<OAuthScope>;
+    redirectSignIn: Array<string>;
+    redirectSignOut: Array<string>;
+    responseType: 'code' | 'token';
+    providers?: Array<OAuthProvider | CustomProvider>;
+};
+export type OAuthProvider = 'Google' | 'Facebook' | 'Amazon' | 'Apple';
+type CustomProvider = {
+    custom: string;
+};
+type CustomScope = string & {};
+type OAuthScope = 'email' | 'openid' | 'phone' | 'email' | 'profile' | 'aws.cognito.signin.user.admin' | CustomScope;
+export type CognitoUserPoolWithOAuthConfig = CognitoUserPoolConfig & {
+    loginWith: {
+        oauth: OAuthConfig;
+    };
+};
+export type AuthUserPoolAndIdentityPoolConfig = {
+    Cognito: CognitoUserPoolAndIdentityPoolConfig;
+};
+export type CognitoUserPoolAndIdentityPoolConfig = CognitoUserPoolConfig & CognitoIdentityPoolConfig;
+export type GetCredentialsOptions = GetCredentialsAuthenticatedUser | GetCredentialsUnauthenticatedUser;
+type GetCredentialsAuthenticatedUser = {
+    authenticated: true;
+    forceRefresh?: boolean;
+    authConfig: AuthConfig | undefined;
+    tokens: AuthTokens;
+};
+type GetCredentialsUnauthenticatedUser = {
+    authenticated: false;
+    forceRefresh?: boolean;
+    authConfig: AuthConfig | undefined;
+    tokens?: never;
+};
+export type AWSCredentialsAndIdentityId = {
+    credentials: AWSCredentials;
+    identityId?: string;
+};
+export type AWSCredentials = {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    expiration?: Date;
+};
+export {};

package/lib-esm/singleton/Auth/types.js

@@ -0,0 +1,5 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// From https://github.com/awslabs/aws-jwt-verify/blob/main/src/safe-json-parse.ts
+// From https://github.com/awslabs/aws-jwt-verify/blob/main/src/jwt-model.ts
+export {};

package/lib-esm/singleton/Auth/utils/errorHelpers.d.ts

@@ -0,0 +1,8 @@
+import { AssertionFunction } from '../../../types';
+export declare enum AuthConfigurationErrorCode {
+    AuthTokenConfigException = "AuthTokenConfigException",
+    AuthUserPoolAndIdentityPoolException = "AuthUserPoolAndIdentityPoolException",
+    InvalidIdentityPoolIdException = "InvalidIdentityPoolIdException",
+    OAuthNotConfigureException = "OAuthNotConfigureException"
+}
+export declare const assert: AssertionFunction<AuthConfigurationErrorCode>;

package/lib-esm/singleton/Auth/utils/errorHelpers.js

@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { createAssertionFunction } from '../../../errors';
+export var AuthConfigurationErrorCode;
+(function (AuthConfigurationErrorCode) {
+    AuthConfigurationErrorCode["AuthTokenConfigException"] = "AuthTokenConfigException";
+    AuthConfigurationErrorCode["AuthUserPoolAndIdentityPoolException"] = "AuthUserPoolAndIdentityPoolException";
+    AuthConfigurationErrorCode["InvalidIdentityPoolIdException"] = "InvalidIdentityPoolIdException";
+    AuthConfigurationErrorCode["OAuthNotConfigureException"] = "OAuthNotConfigureException";
+})(AuthConfigurationErrorCode || (AuthConfigurationErrorCode = {}));
+const authConfigurationErrorMap = {
+    [AuthConfigurationErrorCode.AuthTokenConfigException]: {
+        message: 'Auth Token Provider not configured.',
+        recoverySuggestion: 'Make sure to call Amplify.configure in your app.',
+    },
+    [AuthConfigurationErrorCode.AuthUserPoolAndIdentityPoolException]: {
+        message: 'Auth UserPool or IdentityPool not configured.',
+        recoverySuggestion: 'Make sure to call Amplify.configure in your app with UserPoolId and IdentityPoolId.',
+    },
+    [AuthConfigurationErrorCode.InvalidIdentityPoolIdException]: {
+        message: 'Invalid identity pool id provided.',
+        recoverySuggestion: 'Make sure a valid identityPoolId is given in the config.',
+    },
+    [AuthConfigurationErrorCode.OAuthNotConfigureException]: {
+        message: 'oauth param not configured.',
+        recoverySuggestion: 'Make sure to call Amplify.configure with oauth parameter in your app.',
+    },
+};
+export const assert = createAssertionFunction(authConfigurationErrorMap);

package/lib-esm/singleton/Auth/utils/index.d.ts

@@ -0,0 +1,5 @@
+import { JWT, CognitoUserPoolWithOAuthConfig, CognitoUserPoolConfig, CognitoUserPoolAndIdentityPoolConfig, CognitoIdentityPoolConfig, StrictUnion } from '../types';
+export declare function assertTokenProviderConfig(cognitoConfig?: StrictUnion<CognitoUserPoolConfig | CognitoUserPoolAndIdentityPoolConfig | CognitoIdentityPoolConfig>): asserts cognitoConfig is CognitoUserPoolAndIdentityPoolConfig | CognitoUserPoolConfig;
+export declare function assertOAuthConfig(cognitoConfig?: CognitoUserPoolConfig | CognitoUserPoolAndIdentityPoolConfig): asserts cognitoConfig is CognitoUserPoolWithOAuthConfig;
+export declare function assertIdentityPoolIdConfig(cognitoConfig?: StrictUnion<CognitoUserPoolConfig | CognitoUserPoolAndIdentityPoolConfig | CognitoIdentityPoolConfig>): asserts cognitoConfig is CognitoIdentityPoolConfig;
+export declare function decodeJWT(token: string): JWT;

package/lib-esm/singleton/Auth/utils/index.js

@@ -0,0 +1,53 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { AuthConfigurationErrorCode, assert } from './errorHelpers';
+import { base64Decoder } from '../../../utils/convert';
+export function assertTokenProviderConfig(cognitoConfig) {
+    let assertionValid = true; // assume valid until otherwise proveed
+    if (!cognitoConfig) {
+        assertionValid = false;
+    }
+    else {
+        assertionValid =
+            !!cognitoConfig.userPoolId && !!cognitoConfig.userPoolClientId;
+    }
+    return assert(assertionValid, AuthConfigurationErrorCode.AuthTokenConfigException);
+}
+export function assertOAuthConfig(cognitoConfig) {
+    const validOAuthConfig = !!cognitoConfig?.loginWith?.oauth?.domain &&
+        !!cognitoConfig?.loginWith?.oauth?.redirectSignOut &&
+        !!cognitoConfig?.loginWith?.oauth?.redirectSignIn &&
+        !!cognitoConfig?.loginWith?.oauth?.responseType;
+    return assert(validOAuthConfig, AuthConfigurationErrorCode.OAuthNotConfigureException);
+}
+export function assertIdentityPoolIdConfig(cognitoConfig) {
+    const validConfig = !!cognitoConfig?.identityPoolId;
+    return assert(validConfig, AuthConfigurationErrorCode.InvalidIdentityPoolIdException);
+}
+function assertUserPoolAndIdentityPoolConfig(authConfig) {
+    const validConfig = !!authConfig?.Cognito.identityPoolId && !!authConfig?.Cognito.userPoolId;
+    return assert(validConfig, AuthConfigurationErrorCode.AuthUserPoolAndIdentityPoolException);
+}
+export function decodeJWT(token) {
+    const tokenParts = token.split('.');
+    if (tokenParts.length !== 3) {
+        throw new Error('Invalid token');
+    }
+    try {
+        const base64WithUrlSafe = tokenParts[1];
+        const base64 = base64WithUrlSafe.replace(/-/g, '+').replace(/_/g, '/');
+        const jsonStr = decodeURIComponent(base64Decoder
+            .convert(base64)
+            .split('')
+            .map(char => `%${`00${char.charCodeAt(0).toString(16)}`.slice(-2)}`)
+            .join(''));
+        const payload = JSON.parse(jsonStr);
+        return {
+            toString: () => token,
+            payload,
+        };
+    }
+    catch (err) {
+        throw new Error('Invalid token payload');
+    }
+}