From 42db720ac46d8c1bbd307cd21924b934e7b1b270 Mon Sep 17 00:00:00 2001 From: James Jarvis Date: Thu, 31 Oct 2024 11:33:07 -0700 Subject: [PATCH 01/18] feat(auth): add support for Email MFA (#13945) * [Email MFA] Updating fetchMFAPreference and updateMFAPreference (#13720) * add EMAIL MFA option in fetchMFAPreference * add EMAIL MFA option in updateMFAPreference * update fetchMFAPreference tests * update updateMFAPreference tests * update bundle size * remove redundant assertions * [Email MFA] Add support for EMAIL_OTP during sign in flows (#13745) * Confirm Sign In With Email OTP * Confirm Sign In Tests With Email OTP * Update packages/auth/src/types/models.ts Co-authored-by: israx <70438514+israx@users.noreply.github.com> * Fix Errant Pascal Casing --------- Co-authored-by: israx <70438514+israx@users.noreply.github.com> * feat(auth): [EMAIL MFA] Sign In / Confirm Sign In With MFA_SETUP (#13760) * Sign In / Confirm Sign In With MFA_SETUP * Sign In State Management Tests * Confirm Sign In Happy Path Tests * Fix State Management Tests * Apply Feedback * loose email matching * Remove Unnecessary Export * Update SignInHelpers For Getting Allowed MFA Setup Types * Add Error Case Unit Tests * feat(auth): [EMAIL MFA] enable integ tests with backend configuration swapping (#13794) * chore: enable mfa integ tests * chore: add mfa-setup test def * chore: temporarily enable push integ tests * chore: disable push integ tests * chore: address test strategy feedback * chore: use trimmed challenge response * chore: improved naming * chore: update bundle size tests * chore: remove trimmed challenge response --------- Co-authored-by: israx <70438514+israx@users.noreply.github.com> --- .github/integ-config/integ-all.yml | 45 ++ .github/workflows/callable-e2e-test.yml | 11 +- .github/workflows/callable-e2e-tests.yml | 1 + .../cognito/confirmSignInErrorCases.test.ts | 24 +- .../cognito/confirmSignInHappyCases.test.ts | 446 +++++++++++++++++- .../cognito/fetchMFAPreference.test.ts | 91 +++- .../cognito/signInErrorCases.test.ts | 51 +- .../cognito/testUtils/authApiTestParams.ts | 25 +- .../cognito/updateMFAPreference.test.ts | 64 ++- packages/auth/src/common/AuthErrorStrings.ts | 6 +- .../cognitoIdentityProvider/types/sdk.ts | 24 +- .../providers/cognito/apis/confirmSignIn.ts | 4 +- .../cognito/apis/updateMFAPreference.ts | 3 +- .../src/providers/cognito/types/inputs.ts | 1 + .../providers/cognito/utils/signInHelpers.ts | 412 +++++++++------- packages/auth/src/types/models.ts | 49 +- packages/aws-amplify/package.json | 2 +- 17 files changed, 1021 insertions(+), 238 deletions(-) diff --git a/.github/integ-config/integ-all.yml b/.github/integ-config/integ-all.yml index c7316c37c1f..94a2d85a157 100644 --- a/.github/integ-config/integ-all.yml +++ b/.github/integ-config/integ-all.yml @@ -870,3 +870,48 @@ tests: spec: ssr-context-isolation yarn_script: ci:ssr-context-isolation browser: [chrome] + - test_name: integ_next_mfa_req_email + desc: 'mfa required with email sign in attribute' + framework: next + category: auth + sample_name: [mfa] + spec: mfa-req-email + browser: [chrome] + env: + NEXT_PUBLIC_BACKEND_CONFIG: mfa-req-email + - test_name: integ_next_mfa_req_phone + desc: 'mfa required with phone sign in attribute' + framework: next + category: auth + sample_name: [mfa] + spec: mfa-req-phone + browser: [chrome] + env: + NEXT_PUBLIC_BACKEND_CONFIG: mfa-req-phone + - test_name: integ_next_mfa_opt_email + desc: 'mfa optional with email sign in attribute' + framework: next + category: auth + sample_name: [mfa] + spec: mfa-opt-email + browser: [chrome] + env: + NEXT_PUBLIC_BACKEND_CONFIG: mfa-opt-email + - test_name: integ_next_mfa_opt_phone + desc: 'mfa optional with phone sign in attribute' + framework: next + category: auth + sample_name: [mfa] + spec: mfa-opt-phone + browser: [chrome] + env: + NEXT_PUBLIC_BACKEND_CONFIG: mfa-opt-phone + - test_name: integ_next_mfa_setup + desc: 'mfa setup sign in flow' + framework: next + category: auth + sample_name: [mfa] + spec: mfa-setup + browser: [chrome] + env: + NEXT_PUBLIC_BACKEND_CONFIG: mfa-setup diff --git a/.github/workflows/callable-e2e-test.yml b/.github/workflows/callable-e2e-test.yml index 18697cf5dc5..7df6b042969 100644 --- a/.github/workflows/callable-e2e-test.yml +++ b/.github/workflows/callable-e2e-test.yml @@ -37,6 +37,9 @@ on: yarn_script: required: false type: string + env: + required: false + type: string env: AMPLIFY_DIR: /home/runner/work/amplify-js/amplify-js/amplify-js @@ -84,6 +87,7 @@ jobs: E2E_RETRY_COUNT: ${{ inputs.retry_count }} E2E_TEST_NAME: ${{ inputs.test_name }} E2E_YARN_SCRIPT: ${{ inputs.yarn_script }} + E2E_ENV: ${{ inputs.env }} run: | if [ -z "$E2E_YARN_SCRIPT" ]; then ../amplify-js/scripts/retry-yarn-script.sh -s \ @@ -95,7 +99,8 @@ jobs: $E2E_BROWSER \ dev \ $E2E_BACKEND \ - $E2E_AMPLIFY_JS_DIR" \ + $E2E_AMPLIFY_JS_DIR \ + --env $(echo $E2E_ENV | jq -r 'tostring')" \ $E2E_YARN_SCRIPT \ -n $E2E_RETRY_COUNT else @@ -115,6 +120,7 @@ jobs: E2E_RETRY_COUNT: ${{ inputs.retry_count }} E2E_TEST_NAME: ${{ inputs.test_name }} E2E_YARN_SCRIPT: ${{ inputs.yarn_script }} + E2E_ENV: ${{ inputs.env }} run: | if [ -z "$E2E_YARN_SCRIPT" ]; then ../amplify-js/scripts/retry-yarn-script.sh -s \ @@ -126,7 +132,8 @@ jobs: $E2E_BROWSER \ prod \ $E2E_BACKEND \ - $E2E_AMPLIFY_JS_DIR" \ + $E2E_AMPLIFY_JS_DIR \ + --env $(echo $E2E_ENV | jq -r 'tostring')" \ $E2E_YARN_SCRIPT \ -n $E2E_RETRY_COUNT else diff --git a/.github/workflows/callable-e2e-tests.yml b/.github/workflows/callable-e2e-tests.yml index 4ae74a69c88..2b7604b1215 100644 --- a/.github/workflows/callable-e2e-tests.yml +++ b/.github/workflows/callable-e2e-tests.yml @@ -44,6 +44,7 @@ jobs: timeout_minutes: ${{ matrix.integ-config.timeout_minutes || 35 }} retry_count: ${{ matrix.integ-config.retry_count || 3 }} yarn_script: ${{ matrix.integ-config.yarn_script || '' }} + env: ${{ matrix.integ-config.env && toJSON(matrix.integ-config.env) || '{}' }} # e2e-test-runner-headless: # name: E2E test runnner_headless diff --git a/packages/auth/__tests__/providers/cognito/confirmSignInErrorCases.test.ts b/packages/auth/__tests__/providers/cognito/confirmSignInErrorCases.test.ts index a2d561799d9..39e4fdd8c81 100644 --- a/packages/auth/__tests__/providers/cognito/confirmSignInErrorCases.test.ts +++ b/packages/auth/__tests__/providers/cognito/confirmSignInErrorCases.test.ts @@ -5,6 +5,7 @@ import { AuthValidationErrorCode } from '../../../src/errors/types/validation'; import { confirmSignIn } from '../../../src/providers/cognito/apis/confirmSignIn'; import { RespondToAuthChallengeException } from '../../../src/providers/cognito/types/errors'; import { signInStore } from '../../../src/providers/cognito/utils/signInStore'; +import { AuthErrorCodes } from '../../../src/common/AuthErrorStrings'; import { createRespondToAuthChallengeClient } from '../../../src/foundation/factories/serviceClients/cognitoIdentityProvider'; import { getMockError } from './testUtils/data'; @@ -26,7 +27,7 @@ describe('confirmSignIn API error path cases:', () => { const signInSession = '1234234232'; const { username } = authAPITestParams.user1; // assert mocks - const mockStoreGetState = signInStore.getState as jest.Mock; + const mockStoreGetState = jest.mocked(signInStore.getState); const mockRespondToAuthChallenge = jest.fn(); const mockCreateRespondToAuthChallengeClient = jest.mocked( createRespondToAuthChallengeClient, @@ -62,7 +63,7 @@ describe('confirmSignIn API error path cases:', () => { } }); - it('should throw an error when sign-in step is CONTINUE_SIGN_IN_WITH_MFA_SELECTION and challengeResponse is not "SMS" or "TOTP"', async () => { + it('should throw an error when sign-in step is CONTINUE_SIGN_IN_WITH_MFA_SELECTION and challengeResponse is not "SMS", "TOTP", or "EMAIL"', async () => { expect.assertions(2); try { await confirmSignIn({ challengeResponse: 'NO_SMS' }); @@ -88,4 +89,23 @@ describe('confirmSignIn API error path cases:', () => { ); } }); + it('should throw an error when sign-in step is MFA_SETUP and challengeResponse is not valid', async () => { + expect.assertions(3); + + mockStoreGetState.mockReturnValue({ + username, + challengeName: 'MFA_SETUP', + signInSession, + }); + + try { + await confirmSignIn({ + challengeResponse: 'SMS', + }); + } catch (err: any) { + expect(err).toBeInstanceOf(AuthError); + expect(err.name).toBe(AuthErrorCodes.SignInException); + expect(err.message).toContain('SMS'); + } + }); }); diff --git a/packages/auth/__tests__/providers/cognito/confirmSignInHappyCases.test.ts b/packages/auth/__tests__/providers/cognito/confirmSignInHappyCases.test.ts index ddfcc9c2d8e..8ebd38b52e1 100644 --- a/packages/auth/__tests__/providers/cognito/confirmSignInHappyCases.test.ts +++ b/packages/auth/__tests__/providers/cognito/confirmSignInHappyCases.test.ts @@ -14,8 +14,10 @@ import { tokenOrchestrator, } from '../../../src/providers/cognito/tokenProvider'; import { + createAssociateSoftwareTokenClient, createInitiateAuthClient, createRespondToAuthChallengeClient, + createVerifySoftwareTokenClient, } from '../../../src/foundation/factories/serviceClients/cognitoIdentityProvider'; import { RespondToAuthChallengeCommandOutput } from '../../../src/foundation/factories/serviceClients/cognitoIdentityProvider/types'; @@ -35,7 +37,7 @@ const authConfig = { // getCurrentUser is mocked so Hub is able to dispatch a mocked AuthUser // before returning an `AuthSignInResult` -const mockedGetCurrentUser = getCurrentUser as jest.Mock; +const mockedGetCurrentUser = jest.mocked(getCurrentUser); describe('confirmSignIn API happy path cases', () => { let handleChallengeNameSpy: jest.SpyInstance; @@ -135,6 +137,55 @@ describe('confirmSignIn API happy path cases', () => { mockedGetCurrentUser.mockClear(); }); + test(`confirmSignIn with EMAIL_OTP ChallengeName`, async () => { + Amplify.configure({ + Auth: authConfig, + }); + + const handleUserSRPAuthflowSpy = jest + .spyOn(signInHelpers, 'handleUserSRPAuthFlow') + .mockImplementationOnce( + async (): Promise => ({ + ChallengeName: 'EMAIL_OTP', + Session: '1234234232', + $metadata: {}, + ChallengeParameters: { + CODE_DELIVERY_DELIVERY_MEDIUM: 'EMAIL', + CODE_DELIVERY_DESTINATION: 'j***@a***', + }, + }), + ); + + const signInResult = await signIn({ username, password }); + + expect(signInResult).toEqual({ + isSignedIn: false, + nextStep: { + signInStep: 'CONFIRM_SIGN_IN_WITH_EMAIL_CODE', + codeDeliveryDetails: { + deliveryMedium: 'EMAIL', + destination: 'j***@a***', + }, + }, + }); + + const confirmSignInResult = await confirmSignIn({ + challengeResponse: '123456', + }); + + expect(confirmSignInResult).toEqual({ + isSignedIn: true, + nextStep: { + signInStep: 'DONE', + }, + }); + + expect(handleChallengeNameSpy).toHaveBeenCalledTimes(1); + expect(handleUserSRPAuthflowSpy).toHaveBeenCalledTimes(1); + + handleUserSRPAuthflowSpy.mockClear(); + }); + test(`confirmSignIn tests MFA_SETUP challengeName`, async () => { Amplify.configure({ Auth: authConfig, @@ -175,7 +226,7 @@ describe('confirmSignIn API happy path cases', () => { handleUserSRPAuthflowSpy.mockClear(); }); - test(`confirmSignIn tests SELECT_MFA_TYPE challengeName `, async () => { + test(`confirmSignIn with SELECT_MFA_TYPE challengeName and SMS response`, async () => { Amplify.configure({ Auth: authConfig, }); @@ -188,7 +239,7 @@ describe('confirmSignIn API happy path cases', () => { Session: '1234234232', $metadata: {}, ChallengeParameters: { - MFAS_CAN_CHOOSE: '["SMS_MFA","SOFTWARE_TOKEN_MFA"]', + MFAS_CAN_CHOOSE: '["SMS_MFA","SOFTWARE_TOKEN_MFA", "EMAIL_OTP"]', }, }), ); @@ -217,7 +268,7 @@ describe('confirmSignIn API happy path cases', () => { isSignedIn: false, nextStep: { signInStep: 'CONTINUE_SIGN_IN_WITH_MFA_SELECTION', - allowedMFATypes: ['SMS', 'TOTP'], + allowedMFATypes: ['SMS', 'TOTP', 'EMAIL'], }, }); @@ -239,6 +290,121 @@ describe('confirmSignIn API happy path cases', () => { handleUserSRPAuthflowSpy.mockClear(); }); + test(`confirmSignIn with SELECT_MFA_TYPE challengeName and TOTP response`, async () => { + Amplify.configure({ + Auth: authConfig, + }); + + const handleUserSRPAuthflowSpy = jest + .spyOn(signInHelpers, 'handleUserSRPAuthFlow') + .mockImplementationOnce( + async (): Promise => ({ + ChallengeName: 'SELECT_MFA_TYPE', + Session: '1234234232', + $metadata: {}, + ChallengeParameters: { + MFAS_CAN_CHOOSE: '["SMS_MFA","SOFTWARE_TOKEN_MFA", "EMAIL_OTP"]', + }, + }), + ); + + handleChallengeNameSpy.mockImplementationOnce( + async (): Promise => ({ + ChallengeName: 'SOFTWARE_TOKEN_MFA', + $metadata: {}, + Session: '123456789', + ChallengeParameters: {}, + }), + ); + + const signInResult = await signIn({ username, password }); + + expect(signInResult).toEqual({ + isSignedIn: false, + nextStep: { + signInStep: 'CONTINUE_SIGN_IN_WITH_MFA_SELECTION', + allowedMFATypes: ['SMS', 'TOTP', 'EMAIL'], + }, + }); + + const confirmSignInResult = await confirmSignIn({ + challengeResponse: 'TOTP', + }); + + expect(confirmSignInResult).toEqual({ + isSignedIn: false, + nextStep: { + signInStep: 'CONFIRM_SIGN_IN_WITH_TOTP_CODE', + }, + }); + + expect(handleChallengeNameSpy).toHaveBeenCalledTimes(1); + expect(handleUserSRPAuthflowSpy).toHaveBeenCalledTimes(1); + + handleUserSRPAuthflowSpy.mockClear(); + }); + + test(`confirmSignIn with SELECT_MFA_TYPE challengeName and EMAIL response`, async () => { + Amplify.configure({ + Auth: authConfig, + }); + + const handleUserSRPAuthflowSpy = jest + .spyOn(signInHelpers, 'handleUserSRPAuthFlow') + .mockImplementationOnce( + async (): Promise => ({ + ChallengeName: 'SELECT_MFA_TYPE', + Session: '1234234232', + $metadata: {}, + ChallengeParameters: { + MFAS_CAN_CHOOSE: '["SMS_MFA","SOFTWARE_TOKEN_MFA", "EMAIL_OTP"]', + }, + }), + ); + + handleChallengeNameSpy.mockImplementationOnce( + async (): Promise => ({ + ChallengeName: 'EMAIL_OTP', + $metadata: {}, + Session: '1234234232', + ChallengeParameters: { + CODE_DELIVERY_DELIVERY_MEDIUM: 'EMAIL', + CODE_DELIVERY_DESTINATION: 'j***@a***', + }, + }), + ); + + const signInResult = await signIn({ username, password }); + + expect(signInResult).toEqual({ + isSignedIn: false, + nextStep: { + signInStep: 'CONTINUE_SIGN_IN_WITH_MFA_SELECTION', + allowedMFATypes: ['SMS', 'TOTP', 'EMAIL'], + }, + }); + + const confirmSignInResult = await confirmSignIn({ + challengeResponse: 'EMAIL', + }); + + expect(confirmSignInResult).toEqual({ + isSignedIn: false, + nextStep: { + signInStep: 'CONFIRM_SIGN_IN_WITH_EMAIL_CODE', + codeDeliveryDetails: { + deliveryMedium: 'EMAIL', + destination: 'j***@a***', + }, + }, + }); + + expect(handleChallengeNameSpy).toHaveBeenCalledTimes(1); + expect(handleUserSRPAuthflowSpy).toHaveBeenCalledTimes(1); + + handleUserSRPAuthflowSpy.mockClear(); + }); + test('handleChallengeName should be called with clientMetadata and usersub', async () => { Amplify.configure({ Auth: authConfig, @@ -533,3 +699,275 @@ describe('Cognito ASF', () => { ); }); }); + +describe('confirmSignIn MFA_SETUP challenge happy path cases', () => { + const { username, password } = authAPITestParams.user1; + + test('confirmSignIn with multiple MFA_SETUP options using SOFTWARE_TOKEN_MFA', async () => { + Amplify.configure({ + Auth: authConfig, + }); + jest + .spyOn(signInHelpers, 'handleUserSRPAuthFlow') + .mockImplementationOnce( + async (): Promise => + authAPITestParams.RespondToAuthChallengeMultipleMfaSetupOutput, + ); + + const result = await signIn({ username, password }); + + expect(result.isSignedIn).toBe(false); + expect(result.nextStep.signInStep).toBe( + 'CONTINUE_SIGN_IN_WITH_MFA_SETUP_SELECTION', + ); + + const mockAssociateSoftwareToken = jest.fn(); + + jest + .mocked(createAssociateSoftwareTokenClient) + .mockReturnValue(mockAssociateSoftwareToken); + + mockAssociateSoftwareToken.mockResolvedValueOnce({ + SecretCode: 'secret-code', + Session: '12341234', + $metadata: {}, + }); + + const selectMfaToSetupConfirmSignInResult = await confirmSignIn({ + challengeResponse: 'TOTP', + }); + + expect(selectMfaToSetupConfirmSignInResult.isSignedIn).toBe(false); + expect(selectMfaToSetupConfirmSignInResult.nextStep.signInStep).toBe( + 'CONTINUE_SIGN_IN_WITH_TOTP_SETUP', + ); + + const mockVerifySoftwareToken = jest.fn(); + + jest + .mocked(createVerifySoftwareTokenClient) + .mockReturnValue(mockVerifySoftwareToken); + + mockVerifySoftwareToken.mockResolvedValue({ + Session: '12341234', + Status: 'SUCCESS', + $metadata: {}, + }); + + const mockRespondToAuthChallenge = jest.fn(); + + jest + .mocked(createRespondToAuthChallengeClient) + .mockReturnValue(mockRespondToAuthChallenge); + + mockRespondToAuthChallenge.mockImplementationOnce( + async (): Promise => + authAPITestParams.RespondToAuthChallengeCommandOutput, + ); + + const totpCode = '123456'; + const confirmSignInResult = await confirmSignIn({ + challengeResponse: totpCode, + }); + + expect(mockVerifySoftwareToken).toHaveBeenCalledWith( + expect.objectContaining({ + region: 'us-west-2', + }), + expect.objectContaining({ + UserCode: totpCode, + Session: '12341234', + }), + ); + expect(confirmSignInResult.isSignedIn).toBe(true); + expect(confirmSignInResult.nextStep.signInStep).toBe('DONE'); + }); + + test('confirmSignIn with multiple MFA_SETUP options using EMAIL_OTP', async () => { + Amplify.configure({ + Auth: authConfig, + }); + + jest + .spyOn(signInHelpers, 'handleUserSRPAuthFlow') + .mockImplementationOnce( + async (): Promise => + authAPITestParams.RespondToAuthChallengeMultipleMfaSetupOutput, + ); + + const result = await signIn({ username, password }); + + expect(result.isSignedIn).toBe(false); + expect(result.nextStep.signInStep).toBe( + 'CONTINUE_SIGN_IN_WITH_MFA_SETUP_SELECTION', + ); + + const selectMfaToSetupConfirmSignInResult = await confirmSignIn({ + challengeResponse: 'EMAIL', + }); + + expect(selectMfaToSetupConfirmSignInResult.isSignedIn).toBe(false); + expect(selectMfaToSetupConfirmSignInResult.nextStep.signInStep).toBe( + 'CONTINUE_SIGN_IN_WITH_EMAIL_SETUP', + ); + + jest.spyOn(signInHelpers, 'handleChallengeName').mockImplementationOnce( + async (): Promise => ({ + ChallengeName: 'EMAIL_OTP', + Session: '1234234232', + $metadata: {}, + ChallengeParameters: { + CODE_DELIVERY_DELIVERY_MEDIUM: 'EMAIL', + CODE_DELIVERY_DESTINATION: 'j***@a***', + }, + }), + ); + + const setupEmailConfirmSignInResult = await confirmSignIn({ + challengeResponse: 'j***@a***', + }); + + expect(setupEmailConfirmSignInResult.nextStep.signInStep).toBe( + 'CONFIRM_SIGN_IN_WITH_EMAIL_CODE', + ); + + const mockRespondToAuthChallenge = jest.fn(); + + jest + .mocked(createRespondToAuthChallengeClient) + .mockReturnValue(mockRespondToAuthChallenge); + + mockRespondToAuthChallenge.mockImplementationOnce( + async (): Promise => + authAPITestParams.RespondToAuthChallengeCommandOutput, + ); + + const confirmSignInResult = await confirmSignIn({ + challengeResponse: '123456', + }); + + expect(confirmSignInResult.isSignedIn).toBe(true); + expect(confirmSignInResult.nextStep.signInStep).toBe('DONE'); + }); + + test('confirmSignIn with single MFA_SETUP option using EMAIL_OTP', async () => { + Amplify.configure({ + Auth: authConfig, + }); + + jest + .spyOn(signInHelpers, 'handleUserSRPAuthFlow') + .mockImplementationOnce( + async (): Promise => + authAPITestParams.RespondToAuthChallengeEmailMfaSetupOutput, + ); + + const result = await signIn({ username, password }); + + expect(result.isSignedIn).toBe(false); + expect(result.nextStep.signInStep).toBe( + 'CONTINUE_SIGN_IN_WITH_EMAIL_SETUP', + ); + + jest.spyOn(signInHelpers, 'handleChallengeName').mockImplementationOnce( + async (): Promise => ({ + ChallengeName: 'EMAIL_OTP', + Session: '1234234232', + $metadata: {}, + ChallengeParameters: { + CODE_DELIVERY_DELIVERY_MEDIUM: 'EMAIL', + CODE_DELIVERY_DESTINATION: 'j***@a***', + }, + }), + ); + + const setupEmailConfirmSignInResult = await confirmSignIn({ + challengeResponse: 'j***@a***', + }); + + expect(setupEmailConfirmSignInResult.nextStep.signInStep).toBe( + 'CONFIRM_SIGN_IN_WITH_EMAIL_CODE', + ); + + jest + .spyOn(signInHelpers, 'handleChallengeName') + .mockImplementationOnce( + async (): Promise => + authAPITestParams.RespondToAuthChallengeCommandOutput, + ); + + const confirmSignInResult = await confirmSignIn({ + challengeResponse: '123456', + }); + + expect(confirmSignInResult.isSignedIn).toBe(true); + expect(confirmSignInResult.nextStep.signInStep).toBe('DONE'); + }); + + test('confirmSignIn with single MFA_SETUP option using SOFTWARE_TOKEN_MFA', async () => { + Amplify.configure({ + Auth: authConfig, + }); + jest + .spyOn(signInHelpers, 'handleUserSRPAuthFlow') + .mockImplementationOnce( + async (): Promise => + authAPITestParams.RespondToAuthChallengeTotpMfaSetupOutput, + ); + + const mockAssociateSoftwareToken = jest.fn(); + jest + .mocked(createAssociateSoftwareTokenClient) + .mockReturnValue(mockAssociateSoftwareToken); + + mockAssociateSoftwareToken.mockResolvedValueOnce({ + SecretCode: 'secret-code', + Session: '12341234', + $metadata: {}, + }); + + const result = await signIn({ username, password }); + + expect(result.isSignedIn).toBe(false); + expect(result.nextStep.signInStep).toBe('CONTINUE_SIGN_IN_WITH_TOTP_SETUP'); + + const mockVerifySoftwareToken = jest.fn(); + jest + .mocked(createVerifySoftwareTokenClient) + .mockReturnValue(mockVerifySoftwareToken); + + mockVerifySoftwareToken.mockResolvedValueOnce({ + Session: '12341234', + Status: 'SUCCESS', + $metadata: {}, + }); + + const mockRespondToAuthChallenge = jest.fn(); + + jest + .mocked(createRespondToAuthChallengeClient) + .mockReturnValue(mockRespondToAuthChallenge); + + mockRespondToAuthChallenge.mockImplementationOnce( + async (): Promise => + authAPITestParams.RespondToAuthChallengeCommandOutput, + ); + + const totpCode = '123456'; + const confirmSignInResult = await confirmSignIn({ + challengeResponse: totpCode, + }); + + expect(mockVerifySoftwareToken).toHaveBeenCalledWith( + expect.objectContaining({ + region: 'us-west-2', + }), + expect.objectContaining({ + UserCode: totpCode, + Session: '12341234', + }), + ); + expect(confirmSignInResult.isSignedIn).toBe(true); + expect(confirmSignInResult.nextStep.signInStep).toBe('DONE'); + }); +}); diff --git a/packages/auth/__tests__/providers/cognito/fetchMFAPreference.test.ts b/packages/auth/__tests__/providers/cognito/fetchMFAPreference.test.ts index c4d8a7a9efa..18dba7d80f0 100644 --- a/packages/auth/__tests__/providers/cognito/fetchMFAPreference.test.ts +++ b/packages/auth/__tests__/providers/cognito/fetchMFAPreference.test.ts @@ -24,7 +24,7 @@ jest.mock('../../../src/providers/cognito/factories'); describe('fetchMFAPreference', () => { // assert mocks - const mockFetchAuthSession = fetchAuthSession as jest.Mock; + const mockFetchAuthSession = jest.mocked(fetchAuthSession); const mockGetUser = jest.fn(); const mockCreateGetUserClient = jest.mocked(createGetUserClient); const mockCreateCognitoUserPoolEndpointResolver = jest.mocked( @@ -36,37 +36,77 @@ describe('fetchMFAPreference', () => { mockFetchAuthSession.mockResolvedValue({ tokens: { accessToken: decodeJWT(mockAccessToken) }, }); + mockCreateGetUserClient.mockReturnValue(mockGetUser); }); - beforeEach(() => { - mockGetUser.mockResolvedValue({ + afterEach(() => { + mockGetUser.mockReset(); + mockFetchAuthSession.mockClear(); + }); + + it('should return correct MFA preferences when SMS is preferred', async () => { + mockGetUser.mockResolvedValueOnce({ UserAttributes: [], Username: 'XXXXXXXX', PreferredMfaSetting: 'SMS_MFA', - UserMFASettingList: ['SMS_MFA', 'SOFTWARE_TOKEN_MFA'], + UserMFASettingList: ['SMS_MFA', 'SOFTWARE_TOKEN_MFA', 'EMAIL_OTP'], $metadata: {}, }); - mockCreateGetUserClient.mockReturnValueOnce(mockGetUser); + const resp = await fetchMFAPreference(); + expect(resp).toEqual({ + preferred: 'SMS', + enabled: ['SMS', 'TOTP', 'EMAIL'], + }); }); - afterEach(() => { - mockGetUser.mockReset(); - mockFetchAuthSession.mockClear(); + it('should return correct MFA preferences when EMAIL is preferred', async () => { + mockGetUser.mockResolvedValueOnce({ + UserAttributes: [], + Username: 'XXXXXXXX', + PreferredMfaSetting: 'EMAIL_OTP', + UserMFASettingList: ['SMS_MFA', 'SOFTWARE_TOKEN_MFA', 'EMAIL_OTP'], + $metadata: {}, + }); + const resp = await fetchMFAPreference(); + expect(resp).toEqual({ + preferred: 'EMAIL', + enabled: ['SMS', 'TOTP', 'EMAIL'], + }); }); - - it('should return the preferred MFA setting', async () => { + it('should return correct MFA preferences when TOTP is preferred', async () => { + mockGetUser.mockResolvedValueOnce({ + UserAttributes: [], + Username: 'XXXXXXXX', + PreferredMfaSetting: 'SOFTWARE_TOKEN_MFA', + UserMFASettingList: ['SMS_MFA', 'SOFTWARE_TOKEN_MFA', 'EMAIL_OTP'], + $metadata: {}, + }); const resp = await fetchMFAPreference(); - expect(resp).toEqual({ preferred: 'SMS', enabled: ['SMS', 'TOTP'] }); - expect(mockGetUser).toHaveBeenCalledTimes(1); - expect(mockGetUser).toHaveBeenCalledWith( - { - region: 'us-west-2', - userAgentValue: expect.any(String), - }, - { - AccessToken: mockAccessToken, - }, - ); + expect(resp).toEqual({ + preferred: 'TOTP', + enabled: ['SMS', 'TOTP', 'EMAIL'], + }); + }); + it('should return the correct MFA preferences when there is no preferred option', async () => { + mockGetUser.mockResolvedValueOnce({ + UserAttributes: [], + Username: 'XXXXXXXX', + UserMFASettingList: ['SMS_MFA', 'SOFTWARE_TOKEN_MFA', 'EMAIL_OTP'], + $metadata: {}, + }); + const resp = await fetchMFAPreference(); + expect(resp).toEqual({ + enabled: ['SMS', 'TOTP', 'EMAIL'], + }); + }); + it('should return the correct MFA preferences when there is no available options', async () => { + mockGetUser.mockResolvedValueOnce({ + UserAttributes: [], + Username: 'XXXXXXXX', + $metadata: {}, + }); + const resp = await fetchMFAPreference(); + expect(resp).toEqual({}); }); it('invokes mockCreateCognitoUserPoolEndpointResolver with expected endpointOverride', async () => { @@ -81,6 +121,15 @@ describe('fetchMFAPreference', () => { }, }, }); + + mockGetUser.mockResolvedValueOnce({ + UserAttributes: [], + Username: 'XXXXXXXX', + PreferredMfaSetting: 'SMS_MFA', + UserMFASettingList: ['SMS_MFA', 'SOFTWARE_TOKEN_MFA', 'EMAIL_OTP'], + $metadata: {}, + }); + await fetchMFAPreference(); expect(mockCreateCognitoUserPoolEndpointResolver).toHaveBeenCalledWith({ diff --git a/packages/auth/__tests__/providers/cognito/signInErrorCases.test.ts b/packages/auth/__tests__/providers/cognito/signInErrorCases.test.ts index f66241497f3..94b4029418b 100644 --- a/packages/auth/__tests__/providers/cognito/signInErrorCases.test.ts +++ b/packages/auth/__tests__/providers/cognito/signInErrorCases.test.ts @@ -9,6 +9,7 @@ import { getCurrentUser, signIn } from '../../../src/providers/cognito'; import { InitiateAuthException } from '../../../src/providers/cognito/types/errors'; import { USER_ALREADY_AUTHENTICATED_EXCEPTION } from '../../../src/errors/constants'; import { createInitiateAuthClient } from '../../../src/foundation/factories/serviceClients/cognitoIdentityProvider'; +import { AuthErrorCodes } from '../../../src/common/AuthErrorStrings'; import { authAPITestParams } from './testUtils/authApiTestParams'; import { getMockError } from './testUtils/data'; @@ -26,11 +27,13 @@ jest.mock('../../../src/providers/cognito/apis/getCurrentUser'); jest.mock( '../../../src/foundation/factories/serviceClients/cognitoIdentityProvider', ); +jest.mock('../../../src/providers/cognito/tokenProvider'); describe('signIn API error path cases:', () => { // assert mocks const mockCreateInitiateAuthClient = jest.mocked(createInitiateAuthClient); const mockInitiateAuth = jest.fn(); + const mockedGetCurrentUser = getCurrentUser as jest.Mock; beforeAll(() => { @@ -43,7 +46,7 @@ describe('signIn API error path cases:', () => { afterEach(() => { mockedGetCurrentUser.mockReset(); - mockInitiateAuth.mockClear(); + mockInitiateAuth.mockReset(); }); it('should throw an error when a user is already signed-in', async () => { @@ -88,18 +91,44 @@ describe('signIn API error path cases:', () => { }); it('should throw an error when service returns an error response', async () => { - expect.assertions(2); mockInitiateAuth.mockImplementation(() => { throw getMockError(InitiateAuthException.InvalidParameterException); }); - try { - await signIn({ - username: authAPITestParams.user1.username, - password: authAPITestParams.user1.password, - }); - } catch (error: any) { - expect(error).toBeInstanceOf(AuthError); - expect(error.name).toBe(InitiateAuthException.InvalidParameterException); - } + + const signInResultPromise = signIn({ + username: authAPITestParams.user1.username, + password: authAPITestParams.user1.password, + }); + + expect(signInResultPromise).rejects.toThrow( + new AuthError({ + name: InitiateAuthException.InvalidParameterException, + message: 'Error message', + }), + ); + }); + it('should throw an error when sign in step is MFA_SETUP and there are no valid setup options', async () => { + mockInitiateAuth.mockImplementation(() => ({ + ChallengeName: 'MFA_SETUP', + ChallengeParameters: { + MFAS_CAN_SETUP: '["SMS_MFA"]', + }, + $metadata: {}, + })); + + const signInResultPromise = signIn({ + username: authAPITestParams.user1.username, + password: authAPITestParams.user1.password, + options: { + authFlowType: 'USER_PASSWORD_AUTH', + }, + }); + + expect(signInResultPromise).rejects.toThrow( + new AuthError({ + name: AuthErrorCodes.SignInException, + message: 'Cannot initiate MFA setup from available types: SMS', + }), + ); }); }); diff --git a/packages/auth/__tests__/providers/cognito/testUtils/authApiTestParams.ts b/packages/auth/__tests__/providers/cognito/testUtils/authApiTestParams.ts index 9d5cde07f27..1719bb8d9a4 100644 --- a/packages/auth/__tests__/providers/cognito/testUtils/authApiTestParams.ts +++ b/packages/auth/__tests__/providers/cognito/testUtils/authApiTestParams.ts @@ -112,6 +112,30 @@ export const authAPITestParams = { Session: 'aaabbbcccddd', $metadata: {}, }, + RespondToAuthChallengeMultipleMfaSetupOutput: { + ChallengeName: 'MFA_SETUP', + Session: '1234234232', + $metadata: {}, + ChallengeParameters: { + MFAS_CAN_SETUP: '["SMS_MFA","SOFTWARE_TOKEN_MFA", "EMAIL_OTP"]', + }, + }, + RespondToAuthChallengeEmailMfaSetupOutput: { + ChallengeName: 'MFA_SETUP', + Session: '1234234232', + $metadata: {}, + ChallengeParameters: { + MFAS_CAN_SETUP: '["SMS_MFA", "EMAIL_OTP"]', + }, + }, + RespondToAuthChallengeTotpMfaSetupOutput: { + ChallengeName: 'MFA_SETUP', + Session: '1234234232', + $metadata: {}, + ChallengeParameters: { + MFAS_CAN_SETUP: '["SMS_MFA", "SOFTWARE_TOKEN_MFA"]', + }, + }, CustomChallengeResponse: { ChallengeName: 'CUSTOM_CHALLENGE', AuthenticationResult: undefined, @@ -199,7 +223,6 @@ export const authAPITestParams = { }, GuestIdentityId: { id: 'guest-identity-id', type: 'guest' }, PrimaryIdentityId: { id: 'primary-identity-id', type: 'primary' }, - signInResultWithCustomAuth: () => { return { isSignedIn: false, diff --git a/packages/auth/__tests__/providers/cognito/updateMFAPreference.test.ts b/packages/auth/__tests__/providers/cognito/updateMFAPreference.test.ts index a9d4d6c9e65..0d597b5ec9b 100644 --- a/packages/auth/__tests__/providers/cognito/updateMFAPreference.test.ts +++ b/packages/auth/__tests__/providers/cognito/updateMFAPreference.test.ts @@ -11,12 +11,15 @@ import { import { AuthError } from '../../../src/errors/AuthError'; import { SetUserMFAPreferenceException } from '../../../src/providers/cognito/types/errors'; import { getMFASettings } from '../../../src/providers/cognito/apis/updateMFAPreference'; +import { MFAPreference } from '../../../src/providers/cognito/types'; import { createSetUserMFAPreferenceClient } from '../../../src/foundation/factories/serviceClients/cognitoIdentityProvider'; import { createCognitoUserPoolEndpointResolver } from '../../../src/providers/cognito/factories'; import { getMockError, mockAccessToken } from './testUtils/data'; import { setUpGetConfig } from './testUtils/setUpGetConfig'; +type MfaPreferenceValue = MFAPreference | undefined; + jest.mock('@aws-amplify/core', () => ({ ...(jest.createMockFromModule('@aws-amplify/core') as object), Amplify: { getConfig: jest.fn(() => ({})) }, @@ -30,25 +33,39 @@ jest.mock( ); jest.mock('../../../src/providers/cognito/factories'); -const mfaChoices: UpdateMFAPreferenceInput[] = [ - { sms: 'DISABLED', totp: 'DISABLED' }, - { sms: 'DISABLED', totp: 'ENABLED' }, - { sms: 'DISABLED', totp: 'PREFERRED' }, - { sms: 'DISABLED', totp: 'NOT_PREFERRED' }, - { sms: 'ENABLED', totp: 'DISABLED' }, - { sms: 'ENABLED', totp: 'ENABLED' }, - { sms: 'ENABLED', totp: 'PREFERRED' }, - { sms: 'ENABLED', totp: 'NOT_PREFERRED' }, - { sms: 'PREFERRED', totp: 'DISABLED' }, - { sms: 'PREFERRED', totp: 'ENABLED' }, - { sms: 'PREFERRED', totp: 'PREFERRED' }, - { sms: 'PREFERRED', totp: 'NOT_PREFERRED' }, - { sms: 'NOT_PREFERRED', totp: 'DISABLED' }, - { sms: 'NOT_PREFERRED', totp: 'ENABLED' }, - { sms: 'NOT_PREFERRED', totp: 'PREFERRED' }, - { sms: 'NOT_PREFERRED', totp: 'NOT_PREFERRED' }, - { sms: undefined, totp: undefined }, -]; +// generates all preference permutations +const generateUpdateMFAPreferenceOptions = () => { + const mfaPreferenceTypes: MfaPreferenceValue[] = [ + 'PREFERRED', + 'NOT_PREFERRED', + 'ENABLED', + 'DISABLED', + undefined, + ]; + const mfaKeys: (keyof UpdateMFAPreferenceInput)[] = ['email', 'sms', 'totp']; + + const generatePermutations = ( + keys: string[], + values: T[], + ): Record[] => { + if (!keys.length) return [{}]; + + const [curr, ...rest] = keys; + const permutations: Record[] = []; + + for (const value of values) { + for (const perm of generatePermutations(rest, values)) { + permutations.push({ ...perm, [curr]: value }); + } + } + + return permutations; + }; + + return generatePermutations(mfaKeys, mfaPreferenceTypes); +}; + +const mfaChoices = generateUpdateMFAPreferenceOptions(); describe('updateMFAPreference', () => { // assert mocks @@ -82,10 +99,10 @@ describe('updateMFAPreference', () => { }); it.each(mfaChoices)( - 'should update with sms $sms and totp $totp', - async mfaChoise => { - const { totp, sms } = mfaChoise; - await updateMFAPreference(mfaChoise); + 'should update with email $email, sms $sms, and totp $totp', + async mfaChoice => { + const { totp, sms, email } = mfaChoice; + await updateMFAPreference(mfaChoice); expect(mockSetUserMFAPreference).toHaveBeenCalledWith( { region: 'us-west-2', @@ -95,6 +112,7 @@ describe('updateMFAPreference', () => { AccessToken: mockAccessToken, SMSMfaSettings: getMFASettings(sms), SoftwareTokenMfaSettings: getMFASettings(totp), + EmailMfaSettings: getMFASettings(email), }, ); }, diff --git a/packages/auth/src/common/AuthErrorStrings.ts b/packages/auth/src/common/AuthErrorStrings.ts index c05e4d7bf4c..ad4b8c261ef 100644 --- a/packages/auth/src/common/AuthErrorStrings.ts +++ b/packages/auth/src/common/AuthErrorStrings.ts @@ -47,8 +47,10 @@ export const validationErrorMap: AmplifyErrorMap = { recoverySuggestion: 'Do not include a password in your signIn call.', }, [AuthValidationErrorCode.IncorrectMFAMethod]: { - message: 'Incorrect MFA method was chosen. It should be either SMS or TOTP', - recoverySuggestion: 'Try to pass TOTP or SMS as the challengeResponse', + message: + 'Incorrect MFA method was chosen. It should be either SMS, TOTP, or EMAIL', + recoverySuggestion: + 'Try to pass SMS, TOTP, or EMAIL as the challengeResponse', }, [AuthValidationErrorCode.EmptyVerifyTOTPSetupCode]: { message: 'code is required to verifyTotpSetup', diff --git a/packages/auth/src/foundation/factories/serviceClients/cognitoIdentityProvider/types/sdk.ts b/packages/auth/src/foundation/factories/serviceClients/cognitoIdentityProvider/types/sdk.ts index c08589ad448..f7a1d4a483a 100644 --- a/packages/auth/src/foundation/factories/serviceClients/cognitoIdentityProvider/types/sdk.ts +++ b/packages/auth/src/foundation/factories/serviceClients/cognitoIdentityProvider/types/sdk.ts @@ -8,6 +8,7 @@ import { MetadataBearer as __MetadataBearer } from '@aws-sdk/types'; export type ChallengeName = | 'SMS_MFA' | 'SOFTWARE_TOKEN_MFA' + | 'EMAIL_OTP' | 'SELECT_MFA_TYPE' | 'MFA_SETUP' | 'PASSWORD_VERIFIER' @@ -28,7 +29,7 @@ export type ChallengeParameters = { MFAS_CAN_SETUP?: string; } & Record; -export type CognitoMFAType = 'SMS_MFA' | 'SOFTWARE_TOKEN_MFA'; +export type CognitoMFAType = 'SMS_MFA' | 'SOFTWARE_TOKEN_MFA' | 'EMAIL_OTP'; export interface CognitoMFASettings { Enabled?: boolean; @@ -55,6 +56,7 @@ declare enum ChallengeNameType { SELECT_MFA_TYPE = 'SELECT_MFA_TYPE', SMS_MFA = 'SMS_MFA', SOFTWARE_TOKEN_MFA = 'SOFTWARE_TOKEN_MFA', + EMAIL_OTP = 'EMAIL_OTP', } declare enum DeliveryMediumType { EMAIL = 'EMAIL', @@ -1430,6 +1432,10 @@ export interface SetUserMFAPreferenceRequest { *

The time-based one-time password software token MFA settings.

*/ SoftwareTokenMfaSettings?: SoftwareTokenMfaSettingsType; + /** + *

The email message multi-factor authentication (MFA) settings.

+ */ + EmailMfaSettings?: EmailMfaSettingsType; /** *

The access token for the user.

*/ @@ -1538,6 +1544,22 @@ export interface SoftwareTokenMfaSettingsType { */ PreferredMfa?: boolean; } +/** + *

The type used for enabling email MFA at the user level. If an MFA type is activated for a user, the user will be prompted for MFA during all sign-in attempts, unless device tracking + * is turned on and the device has been trusted. If you want MFA to be applied selectively based on the assessed risk level of sign-in attempts, deactivate MFA for users and turn on Adaptive + * Authentication for the user pool.

+ */ +export interface EmailMfaSettingsType { + /** + *

Specifies whether email MFA is activated. If an MFA type is activated for a user, the user will be prompted for MFA during all sign-in attempts, unless device tracking is turned + * on and the device has been trusted.

+ */ + Enabled?: boolean; + /** + *

Specifies whether email MFA is the preferred MFA method.

+ */ + PreferredMfa?: boolean; +} export type UpdateDeviceStatusCommandInput = UpdateDeviceStatusRequest; export interface UpdateDeviceStatusCommandOutput extends UpdateDeviceStatusResponse, diff --git a/packages/auth/src/providers/cognito/apis/confirmSignIn.ts b/packages/auth/src/providers/cognito/apis/confirmSignIn.ts index b8e8475aa42..2b577f1a1a9 100644 --- a/packages/auth/src/providers/cognito/apis/confirmSignIn.ts +++ b/packages/auth/src/providers/cognito/apis/confirmSignIn.ts @@ -71,8 +71,8 @@ export async function confirmSignIn( throw new AuthError({ name: AuthErrorCodes.SignInException, message: ` - An error occurred during the sign in process. - + An error occurred during the sign in process. + This most likely occurred due to: 1. signIn was not called before confirmSignIn. 2. signIn threw an exception. diff --git a/packages/auth/src/providers/cognito/apis/updateMFAPreference.ts b/packages/auth/src/providers/cognito/apis/updateMFAPreference.ts index 5f87522af5a..200c9e59f0e 100644 --- a/packages/auth/src/providers/cognito/apis/updateMFAPreference.ts +++ b/packages/auth/src/providers/cognito/apis/updateMFAPreference.ts @@ -27,7 +27,7 @@ import { createCognitoUserPoolEndpointResolver } from '../factories'; export async function updateMFAPreference( input: UpdateMFAPreferenceInput, ): Promise { - const { sms, totp } = input; + const { sms, totp, email } = input; const authConfig = Amplify.getConfig().Auth?.Cognito; assertTokenProviderConfig(authConfig); const { userPoolEndpoint, userPoolId } = authConfig; @@ -47,6 +47,7 @@ export async function updateMFAPreference( AccessToken: tokens.accessToken.toString(), SMSMfaSettings: getMFASettings(sms), SoftwareTokenMfaSettings: getMFASettings(totp), + EmailMfaSettings: getMFASettings(email), }, ); } diff --git a/packages/auth/src/providers/cognito/types/inputs.ts b/packages/auth/src/providers/cognito/types/inputs.ts index fa7223f71da..13952bf53e9 100644 --- a/packages/auth/src/providers/cognito/types/inputs.ts +++ b/packages/auth/src/providers/cognito/types/inputs.ts @@ -118,6 +118,7 @@ export type SignUpInput = AuthSignUpInput>; export interface UpdateMFAPreferenceInput { sms?: MFAPreference; totp?: MFAPreference; + email?: MFAPreference; } /** diff --git a/packages/auth/src/providers/cognito/utils/signInHelpers.ts b/packages/auth/src/providers/cognito/utils/signInHelpers.ts index ef4c1422bf3..d3bce2aa6f2 100644 --- a/packages/auth/src/providers/cognito/utils/signInHelpers.ts +++ b/packages/auth/src/providers/cognito/utils/signInHelpers.ts @@ -154,49 +154,116 @@ export async function handleMFASetupChallenge({ config, }: HandleAuthChallengeRequest): Promise { const { userPoolId, userPoolClientId, userPoolEndpoint } = config; - const challengeResponses = { + + if (challengeResponse === 'EMAIL') { + return { + ChallengeName: 'MFA_SETUP', + Session: session, + ChallengeParameters: { + MFAS_CAN_SETUP: '["EMAIL_OTP"]', + }, + $metadata: {}, + }; + } + + if (challengeResponse === 'TOTP') { + return { + ChallengeName: 'MFA_SETUP', + Session: session, + ChallengeParameters: { + MFAS_CAN_SETUP: '["SOFTWARE_TOKEN_MFA"]', + }, + $metadata: {}, + }; + } + + const challengeResponses: Record = { USERNAME: username, }; - const verifySoftwareToken = createVerifySoftwareTokenClient({ - endpointResolver: createCognitoUserPoolEndpointResolver({ - endpointOverride: userPoolEndpoint, - }), - }); - const { Session } = await verifySoftwareToken( - { - region: getRegionFromUserPoolId(userPoolId), - userAgentValue: getAuthUserAgentValue(AuthAction.ConfirmSignIn), - }, - { - UserCode: challengeResponse, + + const isTOTPCode = /^\d+$/.test(challengeResponse); + + if (isTOTPCode) { + const verifySoftwareToken = createVerifySoftwareTokenClient({ + endpointResolver: createCognitoUserPoolEndpointResolver({ + endpointOverride: userPoolEndpoint, + }), + }); + + const { Session } = await verifySoftwareToken( + { + region: getRegionFromUserPoolId(userPoolId), + userAgentValue: getAuthUserAgentValue(AuthAction.ConfirmSignIn), + }, + { + UserCode: challengeResponse, + Session: session, + FriendlyDeviceName: deviceName, + }, + ); + + signInStore.dispatch({ + type: 'SET_SIGN_IN_SESSION', + value: Session, + }); + + const jsonReq: RespondToAuthChallengeCommandInput = { + ChallengeName: 'MFA_SETUP', + ChallengeResponses: challengeResponses, + Session, + ClientMetadata: clientMetadata, + ClientId: userPoolClientId, + }; + + const respondToAuthChallenge = createRespondToAuthChallengeClient({ + endpointResolver: createCognitoUserPoolEndpointResolver({ + endpointOverride: userPoolEndpoint, + }), + }); + + return respondToAuthChallenge( + { + region: getRegionFromUserPoolId(userPoolId), + userAgentValue: getAuthUserAgentValue(AuthAction.ConfirmSignIn), + }, + jsonReq, + ); + } + + const isEmail = challengeResponse.includes('@'); + + if (isEmail) { + challengeResponses.EMAIL = challengeResponse; + + const jsonReq: RespondToAuthChallengeCommandInput = { + ChallengeName: 'MFA_SETUP', + ChallengeResponses: challengeResponses, Session: session, - FriendlyDeviceName: deviceName, - }, - ); + ClientMetadata: clientMetadata, + ClientId: userPoolClientId, + }; - signInStore.dispatch({ - type: 'SET_SIGN_IN_SESSION', - value: Session, - }); + const respondToAuthChallenge = createRespondToAuthChallengeClient({ + endpointResolver: createCognitoUserPoolEndpointResolver({ + endpointOverride: userPoolEndpoint, + }), + }); - const jsonReq: RespondToAuthChallengeCommandInput = { - ChallengeName: 'MFA_SETUP', - ChallengeResponses: challengeResponses, - Session, - ClientMetadata: clientMetadata, - ClientId: userPoolClientId, - }; + return respondToAuthChallenge( + { + region: getRegionFromUserPoolId(userPoolId), + userAgentValue: getAuthUserAgentValue(AuthAction.ConfirmSignIn), + }, + jsonReq, + ); + } - const respondToAuthChallenge = createRespondToAuthChallengeClient({ - endpointResolver: createCognitoUserPoolEndpointResolver({ - endpointOverride: userPoolEndpoint, - }), + throw new AuthError({ + name: AuthErrorCodes.SignInException, + message: `Cannot proceed with MFA setup using challengeResponse: ${challengeResponse}`, + recoverySuggestion: + 'Try passing "EMAIL", "TOTP", a valid email, or OTP code as the challengeResponse.', }); - - return respondToAuthChallenge( - { region: getRegionFromUserPoolId(userPoolId) }, - jsonReq, - ); } export async function handleSelectMFATypeChallenge({ @@ -208,7 +275,9 @@ export async function handleSelectMFATypeChallenge({ }: HandleAuthChallengeRequest): Promise { const { userPoolId, userPoolClientId, userPoolEndpoint } = config; assertValidationError( - challengeResponse === 'TOTP' || challengeResponse === 'SMS', + challengeResponse === 'TOTP' || + challengeResponse === 'SMS' || + challengeResponse === 'EMAIL', AuthValidationErrorCode.IncorrectMFAMethod, ); @@ -247,88 +316,6 @@ export async function handleSelectMFATypeChallenge({ ); } -export async function handleSMSMFAChallenge({ - challengeResponse, - clientMetadata, - session, - username, - config, -}: HandleAuthChallengeRequest): Promise { - const { userPoolId, userPoolClientId, userPoolEndpoint } = config; - const challengeResponses = { - USERNAME: username, - SMS_MFA_CODE: challengeResponse, - }; - const UserContextData = getUserContextData({ - username, - userPoolId, - userPoolClientId, - }); - const jsonReq: RespondToAuthChallengeCommandInput = { - ChallengeName: 'SMS_MFA', - ChallengeResponses: challengeResponses, - Session: session, - ClientMetadata: clientMetadata, - ClientId: userPoolClientId, - UserContextData, - }; - - const respondToAuthChallenge = createRespondToAuthChallengeClient({ - endpointResolver: createCognitoUserPoolEndpointResolver({ - endpointOverride: userPoolEndpoint, - }), - }); - - return respondToAuthChallenge( - { - region: getRegionFromUserPoolId(userPoolId), - userAgentValue: getAuthUserAgentValue(AuthAction.ConfirmSignIn), - }, - jsonReq, - ); -} -export async function handleSoftwareTokenMFAChallenge({ - challengeResponse, - clientMetadata, - session, - username, - config, -}: HandleAuthChallengeRequest): Promise { - const { userPoolId, userPoolClientId, userPoolEndpoint } = config; - const challengeResponses = { - USERNAME: username, - SOFTWARE_TOKEN_MFA_CODE: challengeResponse, - }; - - const UserContextData = getUserContextData({ - username, - userPoolId, - userPoolClientId, - }); - - const jsonReq: RespondToAuthChallengeCommandInput = { - ChallengeName: 'SOFTWARE_TOKEN_MFA', - ChallengeResponses: challengeResponses, - Session: session, - ClientMetadata: clientMetadata, - ClientId: userPoolClientId, - UserContextData, - }; - - const respondToAuthChallenge = createRespondToAuthChallengeClient({ - endpointResolver: createCognitoUserPoolEndpointResolver({ - endpointOverride: userPoolEndpoint, - }), - }); - - return respondToAuthChallenge( - { - region: getRegionFromUserPoolId(userPoolId), - userAgentValue: getAuthUserAgentValue(AuthAction.ConfirmSignIn), - }, - jsonReq, - ); -} export async function handleCompleteNewPasswordChallenge({ challengeResponse, clientMetadata, @@ -842,37 +829,65 @@ export async function getSignInResult(params: { case 'MFA_SETUP': { const { signInSession, username } = signInStore.getState(); - if (!isMFATypeEnabled(challengeParameters, 'TOTP')) - throw new AuthError({ - name: AuthErrorCodes.SignInException, - message: `Cannot initiate MFA setup from available types: ${getMFATypes( - parseMFATypes(challengeParameters.MFAS_CAN_SETUP), - )}`, + const mfaSetupTypes = + getMFATypes(parseMFATypes(challengeParameters.MFAS_CAN_SETUP)) || []; + + const allowedMfaSetupTypes = getAllowedMfaSetupTypes(mfaSetupTypes); + + const isTotpMfaSetupAvailable = allowedMfaSetupTypes.includes('TOTP'); + const isEmailMfaSetupAvailable = allowedMfaSetupTypes.includes('EMAIL'); + + if (isTotpMfaSetupAvailable && isEmailMfaSetupAvailable) { + return { + isSignedIn: false, + nextStep: { + signInStep: 'CONTINUE_SIGN_IN_WITH_MFA_SETUP_SELECTION', + allowedMFATypes: allowedMfaSetupTypes, + }, + }; + } + + if (isEmailMfaSetupAvailable) { + return { + isSignedIn: false, + nextStep: { + signInStep: 'CONTINUE_SIGN_IN_WITH_EMAIL_SETUP', + }, + }; + } + + if (isTotpMfaSetupAvailable) { + const associateSoftwareToken = createAssociateSoftwareTokenClient({ + endpointResolver: createCognitoUserPoolEndpointResolver({ + endpointOverride: authConfig.userPoolEndpoint, + }), + }); + const { Session, SecretCode: secretCode } = + await associateSoftwareToken( + { region: getRegionFromUserPoolId(authConfig.userPoolId) }, + { + Session: signInSession, + }, + ); + + signInStore.dispatch({ + type: 'SET_SIGN_IN_SESSION', + value: Session, }); - const associateSoftwareToken = createAssociateSoftwareTokenClient({ - endpointResolver: createCognitoUserPoolEndpointResolver({ - endpointOverride: authConfig.userPoolEndpoint, - }), - }); - const { Session, SecretCode: secretCode } = await associateSoftwareToken( - { region: getRegionFromUserPoolId(authConfig.userPoolId) }, - { - Session: signInSession, - }, - ); - signInStore.dispatch({ - type: 'SET_SIGN_IN_SESSION', - value: Session, - }); + return { + isSignedIn: false, + nextStep: { + signInStep: 'CONTINUE_SIGN_IN_WITH_TOTP_SETUP', + totpSetupDetails: getTOTPSetupDetails(secretCode!, username), + }, + }; + } - return { - isSignedIn: false, - nextStep: { - signInStep: 'CONTINUE_SIGN_IN_WITH_TOTP_SETUP', - totpSetupDetails: getTOTPSetupDetails(secretCode!, username), - }, - }; + throw new AuthError({ + name: AuthErrorCodes.SignInException, + message: `Cannot initiate MFA setup from available types: ${mfaSetupTypes}`, + }); } case 'NEW_PASSWORD_REQUIRED': return { @@ -913,6 +928,18 @@ export async function getSignInResult(params: { signInStep: 'CONFIRM_SIGN_IN_WITH_TOTP_CODE', }, }; + case 'EMAIL_OTP': + return { + isSignedIn: false, + nextStep: { + signInStep: 'CONFIRM_SIGN_IN_WITH_EMAIL_CODE', + codeDeliveryDetails: { + deliveryMedium: + challengeParameters.CODE_DELIVERY_DELIVERY_MEDIUM as AuthDeliveryMedium, + destination: challengeParameters.CODE_DELIVERY_DESTINATION, + }, + }, + }; case 'ADMIN_NO_SRP_AUTH': break; case 'DEVICE_PASSWORD_VERIFIER': @@ -1000,14 +1027,6 @@ export async function handleChallengeName( const deviceName = options?.friendlyDeviceName; switch (challengeName) { - case 'SMS_MFA': - return handleSMSMFAChallenge({ - challengeResponse, - clientMetadata, - session, - username, - config, - }); case 'SELECT_MFA_TYPE': return handleSelectMFATypeChallenge({ challengeResponse, @@ -1050,8 +1069,11 @@ export async function handleChallengeName( username, tokenOrchestrator, ); + case 'SMS_MFA': case 'SOFTWARE_TOKEN_MFA': - return handleSoftwareTokenMFAChallenge({ + case 'EMAIL_OTP': + return handleMFAChallenge({ + challengeName, challengeResponse, clientMetadata, session, @@ -1062,7 +1084,7 @@ export async function handleChallengeName( // TODO: remove this error message for production apps throw new AuthError({ name: AuthErrorCodes.SignInException, - message: `An error occurred during the sign in process. + message: `An error occurred during the sign in process. ${challengeName} challengeName returned by the underlying service was not addressed.`, }); } @@ -1070,6 +1092,7 @@ export async function handleChallengeName( export function mapMfaType(mfa: string): CognitoMFAType { let mfaType: CognitoMFAType = 'SMS_MFA'; if (mfa === 'TOTP') mfaType = 'SOFTWARE_TOKEN_MFA'; + if (mfa === 'EMAIL') mfaType = 'EMAIL_OTP'; return mfaType; } @@ -1077,6 +1100,7 @@ export function mapMfaType(mfa: string): CognitoMFAType { export function getMFAType(type?: string): AuthMFAType | undefined { if (type === 'SMS_MFA') return 'SMS'; if (type === 'SOFTWARE_TOKEN_MFA') return 'TOTP'; + if (type === 'EMAIL_OTP') return 'EMAIL'; // TODO: log warning for unknown MFA type } @@ -1091,15 +1115,10 @@ export function parseMFATypes(mfa?: string): CognitoMFAType[] { return JSON.parse(mfa) as CognitoMFAType[]; } -export function isMFATypeEnabled( - challengeParams: ChallengeParameters, - mfaType: AuthMFAType, -): boolean { - const { MFAS_CAN_SETUP } = challengeParams; - const mfaTypes = getMFATypes(parseMFATypes(MFAS_CAN_SETUP)); - if (!mfaTypes) return false; - - return mfaTypes.includes(mfaType); +export function getAllowedMfaSetupTypes(availableMfaSetupTypes: AuthMFAType[]) { + return availableMfaSetupTypes.filter( + authMfaType => authMfaType === 'EMAIL' || authMfaType === 'TOTP', + ); } export async function assertUserNotAuthenticated() { @@ -1230,3 +1249,64 @@ export function getActiveSignInUsername(username: string): string { return state.username ?? username; } + +export async function handleMFAChallenge({ + challengeName, + challengeResponse, + clientMetadata, + session, + username, + config, +}: HandleAuthChallengeRequest & { + challengeName: Extract< + ChallengeName, + 'EMAIL_OTP' | 'SMS_MFA' | 'SOFTWARE_TOKEN_MFA' + >; +}) { + const { userPoolId, userPoolClientId, userPoolEndpoint } = config; + + const challengeResponses: Record = { + USERNAME: username, + }; + + if (challengeName === 'EMAIL_OTP') { + challengeResponses.EMAIL_OTP_CODE = challengeResponse; + } + + if (challengeName === 'SMS_MFA') { + challengeResponses.SMS_MFA_CODE = challengeResponse; + } + + if (challengeName === 'SOFTWARE_TOKEN_MFA') { + challengeResponses.SOFTWARE_TOKEN_MFA_CODE = challengeResponse; + } + + const userContextData = getUserContextData({ + username, + userPoolId, + userPoolClientId, + }); + + const jsonReq: RespondToAuthChallengeCommandInput = { + ChallengeName: challengeName, + ChallengeResponses: challengeResponses, + Session: session, + ClientMetadata: clientMetadata, + ClientId: userPoolClientId, + UserContextData: userContextData, + }; + + const respondToAuthChallenge = createRespondToAuthChallengeClient({ + endpointResolver: createCognitoUserPoolEndpointResolver({ + endpointOverride: userPoolEndpoint, + }), + }); + + return respondToAuthChallenge( + { + region: getRegionFromUserPoolId(userPoolId), + userAgentValue: getAuthUserAgentValue(AuthAction.ConfirmSignIn), + }, + jsonReq, + ); +} diff --git a/packages/auth/src/types/models.ts b/packages/auth/src/types/models.ts index 9bcc006141d..e08b7bce5f9 100644 --- a/packages/auth/src/types/models.ts +++ b/packages/auth/src/types/models.ts @@ -44,7 +44,7 @@ export interface AuthTOTPSetupDetails { getSetupUri(appName: string, accountName?: string): URL; } -export type AuthMFAType = 'SMS' | 'TOTP'; +export type AuthMFAType = 'SMS' | 'TOTP' | 'EMAIL'; export type AuthAllowedMFATypes = AuthMFAType[]; @@ -63,6 +63,20 @@ export interface ContinueSignInWithTOTPSetup { signInStep: 'CONTINUE_SIGN_IN_WITH_TOTP_SETUP'; totpSetupDetails: AuthTOTPSetupDetails; } +export interface ContinueSignInWithEmailSetup { + /** + * Auth step requires user to set up EMAIL as multifactor authentication by associating an email address + * and entering the OTP. + * + * @example + * ```typescript + * // Code retrieved from email + * const emailAddress = 'example@example.com'; + * await confirmSignIn({challengeResponse: emailAddress }); + * ``` + */ + signInStep: 'CONTINUE_SIGN_IN_WITH_EMAIL_SETUP'; +} export interface ConfirmSignInWithTOTPCode { /** * Auth step requires user to use TOTP as multifactor authentication by retriving an OTP code from authenticator app. @@ -92,6 +106,21 @@ export interface ContinueSignInWithMFASelection { allowedMFATypes?: AuthAllowedMFATypes; } +export interface ContinueSignInWithMFASetupSelection { + /** + * Auth step requires user to select an mfa option (SMS | TOTP) to setup before continuing the sign-in flow. + * + * @example + * ```typescript + * await confirmSignIn({challengeResponse:'TOTP'}); + * // OR + * await confirmSignIn({challengeResponse:'EMAIL'}); + * ``` + */ + signInStep: 'CONTINUE_SIGN_IN_WITH_MFA_SETUP_SELECTION'; + allowedMFATypes?: AuthAllowedMFATypes; +} + export interface ConfirmSignInWithCustomChallenge { /** * Auth step requires user to respond to a custom challenge. @@ -146,6 +175,21 @@ export interface ConfirmSignInWithSMSCode { codeDeliveryDetails?: AuthCodeDeliveryDetails; } +export interface ConfirmSignInWithEmailCode { + /** + * Auth step requires user to use EMAIL as multifactor authentication by retrieving a code sent to inbox. + * + * @example + * ```typescript + * // Code retrieved from email + * const emailCode = '112233' + * await confirmSignIn({challengeResponse: emailCode}) + * ``` + */ + signInStep: 'CONFIRM_SIGN_IN_WITH_EMAIL_CODE'; + codeDeliveryDetails?: AuthCodeDeliveryDetails; +} + export interface ConfirmSignUpStep { /** * Auth step requires to confirm user's sign-up. @@ -181,7 +225,10 @@ export type AuthNextSignInStep< | ConfirmSignInWithNewPasswordRequired | ConfirmSignInWithSMSCode | ConfirmSignInWithTOTPCode + | ConfirmSignInWithEmailCode | ContinueSignInWithTOTPSetup + | ContinueSignInWithEmailSetup + | ContinueSignInWithMFASetupSelection | ConfirmSignUpStep | ResetPasswordStep | DoneSignInStep; diff --git a/packages/aws-amplify/package.json b/packages/aws-amplify/package.json index d39dd6e0fad..cc14fb0b487 100644 --- a/packages/aws-amplify/package.json +++ b/packages/aws-amplify/package.json @@ -389,7 +389,7 @@ "name": "[Auth] updateMFAPreference (Cognito)", "path": "./dist/esm/auth/index.mjs", "import": "{ updateMFAPreference }", - "limit": "11.98 kB" + "limit": "12.00 kB" }, { "name": "[Auth] fetchMFAPreference (Cognito)", From 3c89069e70328b21e620e256fe89be9c09923cb0 Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Thu, 31 Oct 2024 23:27:34 +0000 Subject: [PATCH 02/18] chore(release): Set core metadata [skip release] --- packages/core/metadata | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/core/metadata b/packages/core/metadata index 001df0f4972..b011e9b696b 100644 --- a/packages/core/metadata +++ b/packages/core/metadata @@ -1 +1 @@ -b02577dc2 +e9f965729 From 8e9d26373f066d55668d85b72b67845c3ad9f2f4 Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Thu, 31 Oct 2024 23:27:49 +0000 Subject: [PATCH 03/18] chore(release): Publish [skip release] - @aws-amplify/adapter-nextjs@1.2.26 - @aws-amplify/analytics@7.0.56 - @aws-amplify/api@6.1.1 - @aws-amplify/api-graphql@4.5.1 - @aws-amplify/api-rest@4.0.56 - @aws-amplify/auth@6.6.0 - aws-amplify@6.8.0 - @aws-amplify/core@6.5.1 - @aws-amplify/datastore@5.0.58 - @aws-amplify/datastore-storage-adapter@2.1.58 - @aws-amplify/geo@3.0.56 - @aws-amplify/interactions@6.0.55 - @aws-amplify/notifications@2.0.56 - @aws-amplify/predictions@6.1.31 - @aws-amplify/pubsub@6.1.31 - @aws-amplify/storage@6.6.14 - tsc-compliance-test@0.1.61 --- packages/adapter-nextjs/CHANGELOG.md | 4 ++++ packages/adapter-nextjs/package.json | 4 ++-- packages/analytics/CHANGELOG.md | 4 ++++ packages/analytics/package.json | 4 ++-- packages/api-graphql/CHANGELOG.md | 4 ++++ packages/api-graphql/package.json | 6 +++--- packages/api-rest/CHANGELOG.md | 4 ++++ packages/api-rest/package.json | 4 ++-- packages/api/CHANGELOG.md | 4 ++++ packages/api/package.json | 6 +++--- packages/auth/CHANGELOG.md | 6 ++++++ packages/auth/package.json | 4 ++-- packages/aws-amplify/CHANGELOG.md | 6 ++++++ packages/aws-amplify/package.json | 16 ++++++++-------- packages/core/CHANGELOG.md | 4 ++++ packages/core/package.json | 2 +- packages/datastore-storage-adapter/CHANGELOG.md | 4 ++++ packages/datastore-storage-adapter/package.json | 6 +++--- packages/datastore/CHANGELOG.md | 4 ++++ packages/datastore/package.json | 6 +++--- packages/geo/CHANGELOG.md | 4 ++++ packages/geo/package.json | 4 ++-- packages/interactions/CHANGELOG.md | 4 ++++ packages/interactions/package.json | 4 ++-- packages/notifications/CHANGELOG.md | 4 ++++ packages/notifications/package.json | 4 ++-- packages/predictions/CHANGELOG.md | 4 ++++ packages/predictions/package.json | 6 +++--- packages/pubsub/CHANGELOG.md | 4 ++++ packages/pubsub/package.json | 6 +++--- packages/storage/CHANGELOG.md | 4 ++++ packages/storage/package.json | 4 ++-- scripts/tsc-compliance-test/CHANGELOG.md | 4 ++++ scripts/tsc-compliance-test/package.json | 4 ++-- 34 files changed, 117 insertions(+), 45 deletions(-) diff --git a/packages/adapter-nextjs/CHANGELOG.md b/packages/adapter-nextjs/CHANGELOG.md index 1b33dade410..063570cf9b0 100644 --- a/packages/adapter-nextjs/CHANGELOG.md +++ b/packages/adapter-nextjs/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [1.2.26](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/adapter-nextjs@1.2.25...@aws-amplify/adapter-nextjs@1.2.26) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/adapter-nextjs + ## [1.2.25](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/adapter-nextjs@1.2.24...@aws-amplify/adapter-nextjs@1.2.25) (2024-10-29) **Note:** Version bump only for package @aws-amplify/adapter-nextjs diff --git a/packages/adapter-nextjs/package.json b/packages/adapter-nextjs/package.json index 8bc0094664d..9ba39ecdb65 100644 --- a/packages/adapter-nextjs/package.json +++ b/packages/adapter-nextjs/package.json @@ -1,7 +1,7 @@ { "author": "Amazon Web Services", "name": "@aws-amplify/adapter-nextjs", - "version": "1.2.25", + "version": "1.2.26", "description": "The adapter for the supporting of using Amplify APIs in Next.js.", "peerDependencies": { "aws-amplify": "^6.0.7", @@ -16,7 +16,7 @@ "@types/node": "^20.3.1", "@types/react": "^18.2.13", "@types/react-dom": "^18.2.6", - "aws-amplify": "6.7.0", + "aws-amplify": "6.8.0", "jest-fetch-mock": "3.0.3", "next": ">= 13.5.0 < 15.0.0", "typescript": "5.0.2" diff --git a/packages/analytics/CHANGELOG.md b/packages/analytics/CHANGELOG.md index af2942bae42..59d4407226e 100644 --- a/packages/analytics/CHANGELOG.md +++ b/packages/analytics/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [7.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/analytics@7.0.55...@aws-amplify/analytics@7.0.56) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/analytics + ## [7.0.55](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/analytics@7.0.54...@aws-amplify/analytics@7.0.55) (2024-10-29) **Note:** Version bump only for package @aws-amplify/analytics diff --git a/packages/analytics/package.json b/packages/analytics/package.json index 1be1cbc04f4..1594730cf8a 100644 --- a/packages/analytics/package.json +++ b/packages/analytics/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/analytics", - "version": "7.0.55", + "version": "7.0.56", "description": "Analytics category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -103,7 +103,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "@aws-amplify/react-native": "1.1.6", "@aws-sdk/types": "3.398.0", "typescript": "5.0.2" diff --git a/packages/api-graphql/CHANGELOG.md b/packages/api-graphql/CHANGELOG.md index 3e9885484b2..18087e6f6f1 100644 --- a/packages/api-graphql/CHANGELOG.md +++ b/packages/api-graphql/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [4.5.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-graphql@4.5.0...@aws-amplify/api-graphql@4.5.1) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/api-graphql + # [4.5.0](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-graphql@4.4.3...@aws-amplify/api-graphql@4.5.0) (2024-10-29) ### Bug Fixes diff --git a/packages/api-graphql/package.json b/packages/api-graphql/package.json index 9d912fea340..1d1486a9c16 100644 --- a/packages/api-graphql/package.json +++ b/packages/api-graphql/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/api-graphql", - "version": "4.5.0", + "version": "4.5.1", "description": "Api-graphql category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -84,8 +84,8 @@ "server" ], "dependencies": { - "@aws-amplify/api-rest": "4.0.55", - "@aws-amplify/core": "6.5.0", + "@aws-amplify/api-rest": "4.0.56", + "@aws-amplify/core": "6.5.1", "@aws-amplify/data-schema": "^1.7.0", "@aws-sdk/types": "3.387.0", "graphql": "15.8.0", diff --git a/packages/api-rest/CHANGELOG.md b/packages/api-rest/CHANGELOG.md index 0b26f8d90af..b2554e6aa49 100644 --- a/packages/api-rest/CHANGELOG.md +++ b/packages/api-rest/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [4.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-rest@4.0.55...@aws-amplify/api-rest@4.0.56) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/api-rest + ## [4.0.55](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-rest@4.0.54...@aws-amplify/api-rest@4.0.55) (2024-10-29) **Note:** Version bump only for package @aws-amplify/api-rest diff --git a/packages/api-rest/package.json b/packages/api-rest/package.json index e155f28d853..86e830d4964 100644 --- a/packages/api-rest/package.json +++ b/packages/api-rest/package.json @@ -1,7 +1,7 @@ { "name": "@aws-amplify/api-rest", "private": false, - "version": "4.0.55", + "version": "4.0.56", "description": "Api-rest category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -87,7 +87,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" }, diff --git a/packages/api/CHANGELOG.md b/packages/api/CHANGELOG.md index 62c45489d0f..b5e582ce527 100644 --- a/packages/api/CHANGELOG.md +++ b/packages/api/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api@6.1.0...@aws-amplify/api@6.1.1) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/api + # [6.1.0](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api@6.0.56...@aws-amplify/api@6.1.0) (2024-10-29) ### Features diff --git a/packages/api/package.json b/packages/api/package.json index 5234b0a6baf..5a0d531c69f 100644 --- a/packages/api/package.json +++ b/packages/api/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/api", - "version": "6.1.0", + "version": "6.1.1", "description": "Api category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -79,8 +79,8 @@ "server" ], "dependencies": { - "@aws-amplify/api-graphql": "4.5.0", - "@aws-amplify/api-rest": "4.0.55", + "@aws-amplify/api-graphql": "4.5.1", + "@aws-amplify/api-rest": "4.0.56", "tslib": "^2.5.0" } } diff --git a/packages/auth/CHANGELOG.md b/packages/auth/CHANGELOG.md index 9641f27488f..d63deebe930 100644 --- a/packages/auth/CHANGELOG.md +++ b/packages/auth/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [6.6.0](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/auth@6.5.5...@aws-amplify/auth@6.6.0) (2024-10-31) + +### Features + +- **auth:** add support for Email MFA ([#13945](https://github.com/aws-amplify/amplify-js/issues/13945)) ([42db720](https://github.com/aws-amplify/amplify-js/commit/42db720ac46d8c1bbd307cd21924b934e7b1b270)), closes [#13720](https://github.com/aws-amplify/amplify-js/issues/13720) [#13745](https://github.com/aws-amplify/amplify-js/issues/13745) + ## [6.5.5](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/auth@6.5.4...@aws-amplify/auth@6.5.5) (2024-10-29) **Note:** Version bump only for package @aws-amplify/auth diff --git a/packages/auth/package.json b/packages/auth/package.json index c80a1af5beb..5f6dddb0958 100644 --- a/packages/auth/package.json +++ b/packages/auth/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/auth", - "version": "6.5.5", + "version": "6.6.0", "description": "Auth category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -97,7 +97,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "@aws-amplify/react-native": "1.1.6", "@jest/test-sequencer": "^29.7.0", "typescript": "5.0.2" diff --git a/packages/aws-amplify/CHANGELOG.md b/packages/aws-amplify/CHANGELOG.md index 50c3fe8240d..518fd1c590c 100644 --- a/packages/aws-amplify/CHANGELOG.md +++ b/packages/aws-amplify/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [6.8.0](https://github.com/aws-amplify/amplify-js/compare/aws-amplify@6.7.0...aws-amplify@6.8.0) (2024-10-31) + +### Features + +- **auth:** add support for Email MFA ([#13945](https://github.com/aws-amplify/amplify-js/issues/13945)) ([42db720](https://github.com/aws-amplify/amplify-js/commit/42db720ac46d8c1bbd307cd21924b934e7b1b270)), closes [#13720](https://github.com/aws-amplify/amplify-js/issues/13720) [#13745](https://github.com/aws-amplify/amplify-js/issues/13745) + # [6.7.0](https://github.com/aws-amplify/amplify-js/compare/aws-amplify@6.6.7...aws-amplify@6.7.0) (2024-10-29) ### Bug Fixes diff --git a/packages/aws-amplify/package.json b/packages/aws-amplify/package.json index cc14fb0b487..e45fedb59ee 100644 --- a/packages/aws-amplify/package.json +++ b/packages/aws-amplify/package.json @@ -1,6 +1,6 @@ { "name": "aws-amplify", - "version": "6.7.0", + "version": "6.8.0", "description": "AWS Amplify is a JavaScript library for Frontend and mobile developers building cloud-enabled applications.", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -276,13 +276,13 @@ "utils" ], "dependencies": { - "@aws-amplify/analytics": "7.0.55", - "@aws-amplify/api": "6.1.0", - "@aws-amplify/auth": "6.5.5", - "@aws-amplify/core": "6.5.0", - "@aws-amplify/datastore": "5.0.57", - "@aws-amplify/notifications": "2.0.55", - "@aws-amplify/storage": "6.6.13", + "@aws-amplify/analytics": "7.0.56", + "@aws-amplify/api": "6.1.1", + "@aws-amplify/auth": "6.6.0", + "@aws-amplify/core": "6.5.1", + "@aws-amplify/datastore": "5.0.58", + "@aws-amplify/notifications": "2.0.56", + "@aws-amplify/storage": "6.6.14", "tslib": "^2.5.0" }, "devDependencies": { diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md index 0c26ee6aa14..3008cb9c76c 100644 --- a/packages/core/CHANGELOG.md +++ b/packages/core/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.5.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/core@6.5.0...@aws-amplify/core@6.5.1) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/core + # [6.5.0](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/core@6.4.7...@aws-amplify/core@6.5.0) (2024-10-29) ### Features diff --git a/packages/core/package.json b/packages/core/package.json index b21163fabf9..1161de3d320 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/core", - "version": "6.5.0", + "version": "6.5.1", "description": "Core category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", diff --git a/packages/datastore-storage-adapter/CHANGELOG.md b/packages/datastore-storage-adapter/CHANGELOG.md index 28c317ef54b..e67ee0e1f48 100644 --- a/packages/datastore-storage-adapter/CHANGELOG.md +++ b/packages/datastore-storage-adapter/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [2.1.58](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore-storage-adapter@2.1.57...@aws-amplify/datastore-storage-adapter@2.1.58) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/datastore-storage-adapter + ## [2.1.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore-storage-adapter@2.1.56...@aws-amplify/datastore-storage-adapter@2.1.57) (2024-10-29) **Note:** Version bump only for package @aws-amplify/datastore-storage-adapter diff --git a/packages/datastore-storage-adapter/package.json b/packages/datastore-storage-adapter/package.json index 9ba95774995..931a82be895 100644 --- a/packages/datastore-storage-adapter/package.json +++ b/packages/datastore-storage-adapter/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/datastore-storage-adapter", - "version": "2.1.57", + "version": "2.1.58", "description": "SQLite storage adapter for Amplify DataStore ", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -36,8 +36,8 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", - "@aws-amplify/datastore": "5.0.57", + "@aws-amplify/core": "6.5.1", + "@aws-amplify/datastore": "5.0.58", "@types/react-native-sqlite-storage": "5.0.1", "expo-file-system": "13.1.4", "expo-sqlite": "10.1.0", diff --git a/packages/datastore/CHANGELOG.md b/packages/datastore/CHANGELOG.md index 95e381a83d9..2e7b6716df9 100644 --- a/packages/datastore/CHANGELOG.md +++ b/packages/datastore/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [5.0.58](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore@5.0.57...@aws-amplify/datastore@5.0.58) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/datastore + ## [5.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore@5.0.56...@aws-amplify/datastore@5.0.57) (2024-10-29) **Note:** Version bump only for package @aws-amplify/datastore diff --git a/packages/datastore/package.json b/packages/datastore/package.json index ef2717e4267..5b4e7ec8a25 100644 --- a/packages/datastore/package.json +++ b/packages/datastore/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/datastore", - "version": "5.0.57", + "version": "5.0.58", "description": "AppSyncLocal support for aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -44,7 +44,7 @@ "src" ], "dependencies": { - "@aws-amplify/api": "6.1.0", + "@aws-amplify/api": "6.1.1", "buffer": "4.9.2", "idb": "5.0.6", "immer": "9.0.6", @@ -55,7 +55,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "@aws-amplify/react-native": "1.1.6", "@types/uuid-validate": "^0.0.1", "dexie": "3.2.2", diff --git a/packages/geo/CHANGELOG.md b/packages/geo/CHANGELOG.md index 0e6b29e1c8a..86d06731bf0 100644 --- a/packages/geo/CHANGELOG.md +++ b/packages/geo/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [3.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/geo@3.0.55...@aws-amplify/geo@3.0.56) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/geo + ## [3.0.55](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/geo@3.0.54...@aws-amplify/geo@3.0.55) (2024-10-29) **Note:** Version bump only for package @aws-amplify/geo diff --git a/packages/geo/package.json b/packages/geo/package.json index e21a25a0675..564838fef30 100644 --- a/packages/geo/package.json +++ b/packages/geo/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/geo", - "version": "3.0.55", + "version": "3.0.56", "description": "Geo category for aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -76,7 +76,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/interactions/CHANGELOG.md b/packages/interactions/CHANGELOG.md index 8bf80c426bf..993850639b2 100644 --- a/packages/interactions/CHANGELOG.md +++ b/packages/interactions/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.0.55](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/interactions@6.0.54...@aws-amplify/interactions@6.0.55) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/interactions + ## [6.0.54](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/interactions@6.0.53...@aws-amplify/interactions@6.0.54) (2024-10-29) **Note:** Version bump only for package @aws-amplify/interactions diff --git a/packages/interactions/package.json b/packages/interactions/package.json index e11aa3b8975..02f0f5015b7 100644 --- a/packages/interactions/package.json +++ b/packages/interactions/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/interactions", - "version": "6.0.54", + "version": "6.0.55", "description": "Interactions category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -81,7 +81,7 @@ "uuid": "^9.0.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "typescript": "^5.0.2" }, "size-limit": [ diff --git a/packages/notifications/CHANGELOG.md b/packages/notifications/CHANGELOG.md index d7672db6fdb..91e2e473fa9 100644 --- a/packages/notifications/CHANGELOG.md +++ b/packages/notifications/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [2.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/notifications@2.0.55...@aws-amplify/notifications@2.0.56) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/notifications + ## [2.0.55](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/notifications@2.0.54...@aws-amplify/notifications@2.0.55) (2024-10-29) **Note:** Version bump only for package @aws-amplify/notifications diff --git a/packages/notifications/package.json b/packages/notifications/package.json index af148e864c8..5354f3ae8ea 100644 --- a/packages/notifications/package.json +++ b/packages/notifications/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/notifications", - "version": "2.0.55", + "version": "2.0.56", "description": "Notifications category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -98,7 +98,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" } diff --git a/packages/predictions/CHANGELOG.md b/packages/predictions/CHANGELOG.md index f6581ce5075..3973ef20838 100644 --- a/packages/predictions/CHANGELOG.md +++ b/packages/predictions/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.31](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/predictions@6.1.30...@aws-amplify/predictions@6.1.31) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/predictions + ## [6.1.30](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/predictions@6.1.29...@aws-amplify/predictions@6.1.30) (2024-10-29) **Note:** Version bump only for package @aws-amplify/predictions diff --git a/packages/predictions/package.json b/packages/predictions/package.json index 36467bd3615..9ab00354ba6 100644 --- a/packages/predictions/package.json +++ b/packages/predictions/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/predictions", - "version": "6.1.30", + "version": "6.1.31", "description": "Machine learning category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -43,7 +43,7 @@ "src" ], "dependencies": { - "@aws-amplify/storage": "6.6.13", + "@aws-amplify/storage": "6.6.14", "@aws-sdk/client-comprehend": "3.621.0", "@aws-sdk/client-polly": "3.621.0", "@aws-sdk/client-rekognition": "3.621.0", @@ -59,7 +59,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/pubsub/CHANGELOG.md b/packages/pubsub/CHANGELOG.md index bc3e3e531d1..e1c4fe5410b 100644 --- a/packages/pubsub/CHANGELOG.md +++ b/packages/pubsub/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.31](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/pubsub@6.1.30...@aws-amplify/pubsub@6.1.31) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/pubsub + ## [6.1.30](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/pubsub@6.1.29...@aws-amplify/pubsub@6.1.30) (2024-10-29) **Note:** Version bump only for package @aws-amplify/pubsub diff --git a/packages/pubsub/package.json b/packages/pubsub/package.json index 40a1bf58ee8..94864d07f32 100644 --- a/packages/pubsub/package.json +++ b/packages/pubsub/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/pubsub", - "version": "6.1.30", + "version": "6.1.31", "description": "Pubsub category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -73,7 +73,7 @@ "mqtt" ], "dependencies": { - "@aws-amplify/auth": "6.5.5", + "@aws-amplify/auth": "6.6.0", "buffer": "4.9.2", "graphql": "15.8.0", "rxjs": "^7.8.1", @@ -84,7 +84,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/storage/CHANGELOG.md b/packages/storage/CHANGELOG.md index 17e39b3057d..9c46a215ee4 100644 --- a/packages/storage/CHANGELOG.md +++ b/packages/storage/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.6.14](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/storage@6.6.13...@aws-amplify/storage@6.6.14) (2024-10-31) + +**Note:** Version bump only for package @aws-amplify/storage + ## [6.6.13](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/storage@6.6.12...@aws-amplify/storage@6.6.13) (2024-10-29) **Note:** Version bump only for package @aws-amplify/storage diff --git a/packages/storage/package.json b/packages/storage/package.json index 02d611f30aa..9f8fc60e413 100644 --- a/packages/storage/package.json +++ b/packages/storage/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/storage", - "version": "6.6.13", + "version": "6.6.14", "description": "Storage category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -101,7 +101,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.0", + "@aws-amplify/core": "6.5.1", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" } diff --git a/scripts/tsc-compliance-test/CHANGELOG.md b/scripts/tsc-compliance-test/CHANGELOG.md index bd5e759131e..864316eb13c 100644 --- a/scripts/tsc-compliance-test/CHANGELOG.md +++ b/scripts/tsc-compliance-test/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [0.1.61](https://github.com/aws-amplify/amplify-js/compare/tsc-compliance-test@0.1.60...tsc-compliance-test@0.1.61) (2024-10-31) + +**Note:** Version bump only for package tsc-compliance-test + ## [0.1.60](https://github.com/aws-amplify/amplify-js/compare/tsc-compliance-test@0.1.59...tsc-compliance-test@0.1.60) (2024-10-29) **Note:** Version bump only for package tsc-compliance-test diff --git a/scripts/tsc-compliance-test/package.json b/scripts/tsc-compliance-test/package.json index 0529e3fc6d9..9211102a2a0 100644 --- a/scripts/tsc-compliance-test/package.json +++ b/scripts/tsc-compliance-test/package.json @@ -1,11 +1,11 @@ { "name": "tsc-compliance-test", - "version": "0.1.60", + "version": "0.1.61", "license": "MIT", "private": true, "devDependencies": { "@types/node": "16.18.82", - "aws-amplify": "6.7.0", + "aws-amplify": "6.8.0", "typescript": "4.2.x" }, "scripts": { From c92c9286a0c73a8600bd5042cf50fbb978f328c6 Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Thu, 31 Oct 2024 23:29:14 +0000 Subject: [PATCH 04/18] chore(release): Update API docs [skip release] --- docs/api/assets/navigation.js | 2 +- docs/api/assets/search.js | 2 +- .../aws_amplify.auth.UpdateMFAPreferenceInput.html | 5 +++-- ....auth._Reference_Types_.ConfirmSignInWithEmailCode.html | 7 +++++++ ...uth._Reference_Types_.ContinueSignInWithEmailSetup.html | 7 +++++++ ...ference_Types_.ContinueSignInWithMFASetupSelection.html | 7 +++++++ docs/api/modules/_aws_amplify_adapter_nextjs.html | 4 ++-- .../modules/_aws_amplify_datastore_storage_adapter.html | 4 ++-- docs/api/modules/_aws_amplify_geo.html | 4 ++-- docs/api/modules/_aws_amplify_interactions.html | 4 ++-- docs/api/modules/_aws_amplify_predictions.html | 4 ++-- docs/api/modules/_aws_amplify_pubsub.html | 4 ++-- docs/api/modules/aws_amplify.auth._Reference_Types_.html | 3 +++ docs/api/modules/aws_amplify.html | 4 ++-- .../aws_amplify.auth._Reference_Types_.AuthMFAType.html | 2 +- ..._amplify.auth._Reference_Types_.AuthNextSignInStep.html | 2 +- 16 files changed, 45 insertions(+), 20 deletions(-) create mode 100644 docs/api/interfaces/aws_amplify.auth._Reference_Types_.ConfirmSignInWithEmailCode.html create mode 100644 docs/api/interfaces/aws_amplify.auth._Reference_Types_.ContinueSignInWithEmailSetup.html create mode 100644 docs/api/interfaces/aws_amplify.auth._Reference_Types_.ContinueSignInWithMFASetupSelection.html diff --git a/docs/api/assets/navigation.js b/docs/api/assets/navigation.js index 0976fac550e..5acdbc1baa8 100644 --- a/docs/api/assets/navigation.js +++ b/docs/api/assets/navigation.js @@ -1 +1 @@ -window.navigationData = "data:application/octet-stream;base64,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" \ No newline at end of file +window.navigationData = "data:application/octet-stream;base64,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" \ No newline at end of file diff --git a/docs/api/assets/search.js b/docs/api/assets/search.js index 9dcae8a67b0..16ab23502d6 100644 --- a/docs/api/assets/search.js +++ b/docs/api/assets/search.js @@ -1 +1 @@ -window.searchData = "data:application/octet-stream;base64,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"; \ No newline at end of file +window.searchData = "data:application/octet-stream;base64,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"; \ No newline at end of file diff --git a/docs/api/interfaces/aws_amplify.auth.UpdateMFAPreferenceInput.html b/docs/api/interfaces/aws_amplify.auth.UpdateMFAPreferenceInput.html index d29df28f9e7..1aaa197b531 100644 --- a/docs/api/interfaces/aws_amplify.auth.UpdateMFAPreferenceInput.html +++ b/docs/api/interfaces/aws_amplify.auth.UpdateMFAPreferenceInput.html @@ -1,5 +1,6 @@ UpdateMFAPreferenceInput | Amplify JS API Documentation

Interface UpdateMFAPreferenceInput

Input type for Cognito updateMFAPreference API.

-
interface UpdateMFAPreferenceInput {
    sms?: MFAPreference;
    totp?: MFAPreference;
}

Properties

sms? +
interface UpdateMFAPreferenceInput {
    email?: MFAPreference;
    sms?: MFAPreference;
    totp?: MFAPreference;
}

Properties

email? +sms? totp? -

Properties

Optional sms

sms?: MFAPreference

Optional totp

totp?: MFAPreference

Settings

Member Visibility

Theme

On This Page

\ No newline at end of file +

Properties

Optional email

email?: MFAPreference

Optional sms

sms?: MFAPreference

Optional totp

totp?: MFAPreference

Settings

Member Visibility

Theme

On This Page

\ No newline at end of file diff --git a/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ConfirmSignInWithEmailCode.html b/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ConfirmSignInWithEmailCode.html new file mode 100644 index 00000000000..73b2a0f7b56 --- /dev/null +++ b/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ConfirmSignInWithEmailCode.html @@ -0,0 +1,7 @@ +ConfirmSignInWithEmailCode | Amplify JS API Documentation +

Interface ConfirmSignInWithEmailCode

interface ConfirmSignInWithEmailCode {
    codeDeliveryDetails?: AuthCodeDeliveryDetails<AuthUserAttributeKey>;
    signInStep: "CONFIRM_SIGN_IN_WITH_EMAIL_CODE";
}

Properties

codeDeliveryDetails? +signInStep +

Properties

Optional codeDeliveryDetails

codeDeliveryDetails?: AuthCodeDeliveryDetails<AuthUserAttributeKey>

signInStep

signInStep: "CONFIRM_SIGN_IN_WITH_EMAIL_CODE"

Auth step requires user to use EMAIL as multifactor authentication by retrieving a code sent to inbox.

+

Example

// Code retrieved from email
const emailCode = '112233'
await confirmSignIn({challengeResponse: emailCode})
+
+

Settings

Member Visibility

Theme

On This Page

\ No newline at end of file diff --git a/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ContinueSignInWithEmailSetup.html b/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ContinueSignInWithEmailSetup.html new file mode 100644 index 00000000000..84291f430e3 --- /dev/null +++ b/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ContinueSignInWithEmailSetup.html @@ -0,0 +1,7 @@ +ContinueSignInWithEmailSetup | Amplify JS API Documentation +

Interface ContinueSignInWithEmailSetup

interface ContinueSignInWithEmailSetup {
    signInStep: "CONTINUE_SIGN_IN_WITH_EMAIL_SETUP";
}

Properties

signInStep +

Properties

signInStep

signInStep: "CONTINUE_SIGN_IN_WITH_EMAIL_SETUP"

Auth step requires user to set up EMAIL as multifactor authentication by associating an email address +and entering the OTP.

+

Example

// Code retrieved from email
const emailAddress = 'example@example.com';
await confirmSignIn({challengeResponse: emailAddress });
+
+

Settings

Member Visibility

Theme

On This Page

\ No newline at end of file diff --git a/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ContinueSignInWithMFASetupSelection.html b/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ContinueSignInWithMFASetupSelection.html new file mode 100644 index 00000000000..ee3e986de5c --- /dev/null +++ b/docs/api/interfaces/aws_amplify.auth._Reference_Types_.ContinueSignInWithMFASetupSelection.html @@ -0,0 +1,7 @@ +ContinueSignInWithMFASetupSelection | Amplify JS API Documentation +

Interface ContinueSignInWithMFASetupSelection

interface ContinueSignInWithMFASetupSelection {
    allowedMFATypes?: AuthAllowedMFATypes;
    signInStep: "CONTINUE_SIGN_IN_WITH_MFA_SETUP_SELECTION";
}

Properties

allowedMFATypes? +signInStep +

Properties

Optional allowedMFATypes

allowedMFATypes?: AuthAllowedMFATypes

signInStep

signInStep: "CONTINUE_SIGN_IN_WITH_MFA_SETUP_SELECTION"

Auth step requires user to select an mfa option (SMS | TOTP) to setup before continuing the sign-in flow.

+

Example

await confirmSignIn({challengeResponse:'TOTP'});
// OR
await confirmSignIn({challengeResponse:'EMAIL'});
+
+

Settings

Member Visibility

Theme

On This Page

\ No newline at end of file diff --git a/docs/api/modules/_aws_amplify_adapter_nextjs.html b/docs/api/modules/_aws_amplify_adapter_nextjs.html index 80a58dd9f31..ceaadfb75bd 100644 --- a/docs/api/modules/_aws_amplify_adapter_nextjs.html +++ b/docs/api/modules/_aws_amplify_adapter_nextjs.html @@ -1,5 +1,5 @@ -@aws-amplify/adapter-nextjs - v1.2.25 | Amplify JS API Documentation -

Module @aws-amplify/adapter-nextjs - v1.2.25

This package contains the AWS Amplify Next.js Adapter. For more information on using Next.js in your application please reference the Amplify Dev Center.

+@aws-amplify/adapter-nextjs - v1.2.26 | Amplify JS API Documentation +

Module @aws-amplify/adapter-nextjs - v1.2.26

This package contains the AWS Amplify Next.js Adapter. For more information on using Next.js in your application please reference the Amplify Dev Center.

Index

Modules

api index utils diff --git a/docs/api/modules/_aws_amplify_datastore_storage_adapter.html b/docs/api/modules/_aws_amplify_datastore_storage_adapter.html index c9c45204c6b..6e0bf8c3c8b 100644 --- a/docs/api/modules/_aws_amplify_datastore_storage_adapter.html +++ b/docs/api/modules/_aws_amplify_datastore_storage_adapter.html @@ -1,5 +1,5 @@ -@aws-amplify/datastore-storage-adapter - v2.1.57 | Amplify JS API Documentation -

Module @aws-amplify/datastore-storage-adapter - v2.1.57

This package contains the AWS Amplify DataStore storage adapter. For more information on using the DataStore storage adapter in your application please reference the Amplify Dev Center.

+@aws-amplify/datastore-storage-adapter - v2.1.58 | Amplify JS API Documentation +

Module @aws-amplify/datastore-storage-adapter - v2.1.58

This package contains the AWS Amplify DataStore storage adapter. For more information on using the DataStore storage adapter in your application please reference the Amplify Dev Center.

Index

Modules

ExpoSQLiteAdapter/ExpoSQLiteAdapter SQLiteAdapter/SQLiteAdapter index diff --git a/docs/api/modules/_aws_amplify_geo.html b/docs/api/modules/_aws_amplify_geo.html index 7de4c4e88d7..5fd4253860e 100644 --- a/docs/api/modules/_aws_amplify_geo.html +++ b/docs/api/modules/_aws_amplify_geo.html @@ -1,5 +1,5 @@ -@aws-amplify/geo - v3.0.55 | Amplify JS API Documentation -

Module @aws-amplify/geo - v3.0.55

This package contains the AWS Amplify Geo category. For more information on using Geo in your application please reference the Amplify Dev Center.

+@aws-amplify/geo - v3.0.56 | Amplify JS API Documentation +

Module @aws-amplify/geo - v3.0.56

This package contains the AWS Amplify Geo category. For more information on using Geo in your application please reference the Amplify Dev Center.

Index

Modules

index providers/location-service/AmazonLocationServiceProvider

Settings

Member Visibility

Theme

\ No newline at end of file diff --git a/docs/api/modules/_aws_amplify_interactions.html b/docs/api/modules/_aws_amplify_interactions.html index 13ab1195f41..4eee4562580 100644 --- a/docs/api/modules/_aws_amplify_interactions.html +++ b/docs/api/modules/_aws_amplify_interactions.html @@ -1,5 +1,5 @@ -@aws-amplify/interactions - v6.0.54 | Amplify JS API Documentation -

Module @aws-amplify/interactions - v6.0.54

This package contains the AWS Amplify Interactions category. For more information on using Interactions in your application please reference the Amplify Dev Center.

+@aws-amplify/interactions - v6.0.55 | Amplify JS API Documentation +

Module @aws-amplify/interactions - v6.0.55

This package contains the AWS Amplify Interactions category. For more information on using Interactions in your application please reference the Amplify Dev Center.

Index

Modules

index lex-v1 lex-v2 diff --git a/docs/api/modules/_aws_amplify_predictions.html b/docs/api/modules/_aws_amplify_predictions.html index 725916fb415..261a1d51319 100644 --- a/docs/api/modules/_aws_amplify_predictions.html +++ b/docs/api/modules/_aws_amplify_predictions.html @@ -1,5 +1,5 @@ -@aws-amplify/predictions - v6.1.30 | Amplify JS API Documentation -

Module @aws-amplify/predictions - v6.1.30

This package contains the AWS Amplify Predictions category. For more information on using Predictions in your application please reference the Amplify Dev Center.

+@aws-amplify/predictions - v6.1.31 | Amplify JS API Documentation +

Module @aws-amplify/predictions - v6.1.31

This package contains the AWS Amplify Predictions category. For more information on using Predictions in your application please reference the Amplify Dev Center.

Index

Modules

<Reference Types>

Interfaces

IdentifyEntitiesInput IdentifyEntitiesOutput diff --git a/docs/api/modules/_aws_amplify_pubsub.html b/docs/api/modules/_aws_amplify_pubsub.html index ee26e9dce89..93afe0854c0 100644 --- a/docs/api/modules/_aws_amplify_pubsub.html +++ b/docs/api/modules/_aws_amplify_pubsub.html @@ -1,5 +1,5 @@ -@aws-amplify/pubsub - v6.1.30 | Amplify JS API Documentation -

Module @aws-amplify/pubsub - v6.1.30

This package contains the AWS Amplify PubSub category. For more information on using PubSub in your application please reference the Amplify Dev Center.

+@aws-amplify/pubsub - v6.1.31 | Amplify JS API Documentation +

Module @aws-amplify/pubsub - v6.1.31

This package contains the AWS Amplify PubSub category. For more information on using PubSub in your application please reference the Amplify Dev Center.

Index

Modules

clients/iot clients/mqtt index diff --git a/docs/api/modules/aws_amplify.auth._Reference_Types_.html b/docs/api/modules/aws_amplify.auth._Reference_Types_.html index 372d2eacf61..e10a5029571 100644 --- a/docs/api/modules/aws_amplify.auth._Reference_Types_.html +++ b/docs/api/modules/aws_amplify.auth._Reference_Types_.html @@ -32,12 +32,15 @@ AuthVerifyTOTPSetupInput AutoSignInSignUpStep ConfirmSignInWithCustomChallenge +ConfirmSignInWithEmailCode ConfirmSignInWithNewPasswordRequired ConfirmSignInWithSMSCode ConfirmSignInWithTOTPCode ConfirmSignUpSignUpStep ConfirmSignUpStep +ContinueSignInWithEmailSetup ContinueSignInWithMFASelection +ContinueSignInWithMFASetupSelection ContinueSignInWithTOTPSetup DoneSignInStep DoneSignUpStep diff --git a/docs/api/modules/aws_amplify.html b/docs/api/modules/aws_amplify.html index 27d036507bb..8920ff975e0 100644 --- a/docs/api/modules/aws_amplify.html +++ b/docs/api/modules/aws_amplify.html @@ -1,5 +1,5 @@ -aws-amplify - v6.7.0 | Amplify JS API Documentation -

Module aws-amplify - v6.7.0

AWS Amplify Package - aws-amplify

AWS Amplify is a JavaScript library for frontend and mobile developers building cloud-enabled applications. The library is a declarative interface across different categories of operations in order to make common tasks easier to add into your application. The default implementation works with Amazon Web Services (AWS) resources but is designed to be open and pluggable for usage with other cloud services that wish to provide an implementation or custom backends.

+aws-amplify - v6.8.0 | Amplify JS API Documentation +

Module aws-amplify - v6.8.0

AWS Amplify Package - aws-amplify

AWS Amplify is a JavaScript library for frontend and mobile developers building cloud-enabled applications. The library is a declarative interface across different categories of operations in order to make common tasks easier to add into your application. The default implementation works with Amazon Web Services (AWS) resources but is designed to be open and pluggable for usage with other cloud services that wish to provide an implementation or custom backends.

Documentation is available here.

Index

Modules

adapter-core analytics diff --git a/docs/api/types/aws_amplify.auth._Reference_Types_.AuthMFAType.html b/docs/api/types/aws_amplify.auth._Reference_Types_.AuthMFAType.html index d936d6c4185..00d4e399ef5 100644 --- a/docs/api/types/aws_amplify.auth._Reference_Types_.AuthMFAType.html +++ b/docs/api/types/aws_amplify.auth._Reference_Types_.AuthMFAType.html @@ -1,2 +1,2 @@ AuthMFAType | Amplify JS API Documentation -

Type alias AuthMFAType

AuthMFAType: "SMS" | "TOTP"

Settings

Member Visibility

Theme

\ No newline at end of file +

Type alias AuthMFAType

AuthMFAType: "SMS" | "TOTP" | "EMAIL"

Settings

Member Visibility

Theme

\ No newline at end of file diff --git a/docs/api/types/aws_amplify.auth._Reference_Types_.AuthNextSignInStep.html b/docs/api/types/aws_amplify.auth._Reference_Types_.AuthNextSignInStep.html index f4d3df2776a..0a2a6ab5fd3 100644 --- a/docs/api/types/aws_amplify.auth._Reference_Types_.AuthNextSignInStep.html +++ b/docs/api/types/aws_amplify.auth._Reference_Types_.AuthNextSignInStep.html @@ -1,2 +1,2 @@ AuthNextSignInStep | Amplify JS API Documentation -

Type alias AuthNextSignInStep<UserAttributeKey>

AuthNextSignInStep<UserAttributeKey>: ConfirmSignInWithCustomChallenge | ContinueSignInWithMFASelection | ConfirmSignInWithNewPasswordRequired<UserAttributeKey> | ConfirmSignInWithSMSCode | ConfirmSignInWithTOTPCode | ContinueSignInWithTOTPSetup | ConfirmSignUpStep | ResetPasswordStep | DoneSignInStep

Type Parameters

Settings

Member Visibility

Theme

\ No newline at end of file +

Type alias AuthNextSignInStep<UserAttributeKey>

AuthNextSignInStep<UserAttributeKey>: ConfirmSignInWithCustomChallenge | ContinueSignInWithMFASelection | ConfirmSignInWithNewPasswordRequired<UserAttributeKey> | ConfirmSignInWithSMSCode | ConfirmSignInWithTOTPCode | ConfirmSignInWithEmailCode | ContinueSignInWithTOTPSetup | ContinueSignInWithEmailSetup | ContinueSignInWithMFASetupSelection | ConfirmSignUpStep | ResetPasswordStep | DoneSignInStep

Type Parameters

Settings

Member Visibility

Theme

\ No newline at end of file From d6eede3a68df1e6c49927e62ce0b73d6db615a8a Mon Sep 17 00:00:00 2001 From: Ivan Artemiev <29709626+iartemiev@users.noreply.github.com> Date: Mon, 4 Nov 2024 10:23:39 -0500 Subject: [PATCH 05/18] feat(api-graphql): return entire payload in callback (#13980) feat(api-graphql): return entire payload in callback --- .../__tests__/AWSAppSyncEventProvider.test.ts | 34 +++++++++++++++++++ .../AWSAppSyncEventsProvider/index.ts | 2 +- 2 files changed, 35 insertions(+), 1 deletion(-) diff --git a/packages/api-graphql/__tests__/AWSAppSyncEventProvider.test.ts b/packages/api-graphql/__tests__/AWSAppSyncEventProvider.test.ts index d84f1daad89..fbb865be862 100644 --- a/packages/api-graphql/__tests__/AWSAppSyncEventProvider.test.ts +++ b/packages/api-graphql/__tests__/AWSAppSyncEventProvider.test.ts @@ -171,6 +171,40 @@ describe('AppSyncEventProvider', () => { 'Connection failed: Retriable Test', ); }); + + test('subscription observer is triggered when a connection is formed and a data message is received after connection ack', async () => { + expect.assertions(1); + const mockNext = jest.fn(); + + const observer = provider.subscribe({ + appSyncGraphqlEndpoint: 'ws://localhost:8080', + }); + + const event = JSON.stringify({ some: 'data' }); + + observer.subscribe({ + // Succeed only when the first message comes through + next: mockNext, + // Closing a hot connection (for cleanup) makes it blow up the test stack + error: () => {}, + }); + await fakeWebSocketInterface?.standardConnectionHandshake(); + await fakeWebSocketInterface?.startAckMessage({ + connectionTimeoutMs: 100, + }); + await fakeWebSocketInterface?.sendDataMessage({ + id: fakeWebSocketInterface?.webSocket.subscriptionId, + type: MESSAGE_TYPES.DATA, + event, + }); + + // events callback returns entire message contents + expect(mockNext).toHaveBeenCalledWith({ + id: fakeWebSocketInterface?.webSocket.subscriptionId, + type: MESSAGE_TYPES.DATA, + event: JSON.parse(event), + }); + }); }); }); }); diff --git a/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts b/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts index 5bfeddd89fa..eff48289acc 100644 --- a/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts +++ b/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts @@ -167,7 +167,7 @@ export class AWSAppSyncEventProvider extends AWSWebSocketProvider { if (type === MESSAGE_TYPES.DATA && payload) { const deserializedEvent = JSON.parse(payload); if (observer) { - observer.next(deserializedEvent); + observer.next({ id, type, event: deserializedEvent }); } else { this.logger.debug(`observer not found for id: ${id}`); } From 168ecff80ede7c92a2a443471061237f250b1fcd Mon Sep 17 00:00:00 2001 From: Ivan Artemiev <29709626+iartemiev@users.noreply.github.com> Date: Wed, 6 Nov 2024 10:13:24 -0500 Subject: [PATCH 06/18] fix(api-graphql): close WS on events.closeAll (#13989) --- .../__tests__/AWSAppSyncEventProvider.test.ts | 37 +++++++++++++++++++ packages/api-graphql/__tests__/helpers.ts | 7 +++- .../AWSAppSyncEventsProvider/index.ts | 21 +++++++++++ .../Providers/AWSWebSocketProvider/index.ts | 2 +- .../api-graphql/src/internals/events/index.ts | 15 +++++++- 5 files changed, 77 insertions(+), 5 deletions(-) diff --git a/packages/api-graphql/__tests__/AWSAppSyncEventProvider.test.ts b/packages/api-graphql/__tests__/AWSAppSyncEventProvider.test.ts index fbb865be862..a8c29a63e87 100644 --- a/packages/api-graphql/__tests__/AWSAppSyncEventProvider.test.ts +++ b/packages/api-graphql/__tests__/AWSAppSyncEventProvider.test.ts @@ -205,6 +205,43 @@ describe('AppSyncEventProvider', () => { event: JSON.parse(event), }); }); + + test('socket is disconnected after .close() is called', async () => { + expect.assertions(2); + const mockNext = jest.fn(); + + const observer = provider.subscribe({ + appSyncGraphqlEndpoint: 'ws://localhost:8080', + }); + + const event = JSON.stringify({ some: 'data' }); + + observer.subscribe({ + next: mockNext, + error: () => {}, + }); + + await fakeWebSocketInterface?.standardConnectionHandshake(); + await fakeWebSocketInterface?.startAckMessage({ + connectionTimeoutMs: 100, + }); + await fakeWebSocketInterface?.sendDataMessage({ + id: fakeWebSocketInterface?.webSocket.subscriptionId, + type: MESSAGE_TYPES.DATA, + event, + }); + + // events callback returns entire message contents + expect(mockNext).toHaveBeenCalledWith({ + id: fakeWebSocketInterface?.webSocket.subscriptionId, + type: MESSAGE_TYPES.DATA, + event: JSON.parse(event), + }); + + await provider.close(); + + expect(fakeWebSocketInterface.hasClosed).resolves.toBeUndefined(); + }); }); }); }); diff --git a/packages/api-graphql/__tests__/helpers.ts b/packages/api-graphql/__tests__/helpers.ts index ac26232dd90..424fc4e3129 100644 --- a/packages/api-graphql/__tests__/helpers.ts +++ b/packages/api-graphql/__tests__/helpers.ts @@ -258,9 +258,8 @@ export class FakeWebSocketInterface { /** * Run a command and resolve to allow internal behavior to execute */ - async runAndResolve(fn) { + async runAndResolve(fn: Function) { await fn(); - await Promise.resolve(); } /** @@ -310,6 +309,10 @@ class FakeWebSocket implements WebSocket { close(code?: number, reason?: string): void { const closeResolver = this.closeResolverFcn(); if (closeResolver) closeResolver(Promise.resolve(undefined)); + + try { + this.onclose(new CloseEvent('', {})); + } catch {} } send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void { const parsedInput = JSON.parse(String(data)); diff --git a/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts b/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts index eff48289acc..859f69fcde6 100644 --- a/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts +++ b/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts @@ -53,6 +53,27 @@ export class AWSAppSyncEventProvider extends AWSWebSocketProvider { return PROVIDER_NAME; } + close() { + return new Promise((resolve, reject) => { + super.close(); + if (this.awsRealTimeSocket) { + this.awsRealTimeSocket.onclose = (_: CloseEvent) => { + this.subscriptionObserverMap = new Map(); + this.awsRealTimeSocket = undefined; + resolve(); + }; + + this.awsRealTimeSocket.onerror = (err: any) => { + reject(err); + }; + + this.awsRealTimeSocket.close(); + } else { + resolve(); + } + }); + } + public async connect(options: AWSAppSyncEventProviderOptions) { super.connect(options); } diff --git a/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts b/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts index 3553a008123..4a5e0d8f3b0 100644 --- a/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts +++ b/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts @@ -80,7 +80,7 @@ export abstract class AWSWebSocketProvider { protected logger: ConsoleLogger; protected subscriptionObserverMap = new Map(); - private awsRealTimeSocket?: WebSocket; + protected awsRealTimeSocket?: WebSocket; private socketStatus: SOCKET_STATUS = SOCKET_STATUS.CLOSED; private keepAliveTimeoutId?: ReturnType; private keepAliveTimeout = DEFAULT_KEEP_ALIVE_TIMEOUT; diff --git a/packages/api-graphql/src/internals/events/index.ts b/packages/api-graphql/src/internals/events/index.ts index 49860a92049..c1101111fd4 100644 --- a/packages/api-graphql/src/internals/events/index.ts +++ b/packages/api-graphql/src/internals/events/index.ts @@ -154,8 +154,19 @@ async function post( } } -function closeAll(): void { - eventProvider.close(); +/** + * @experimental API may change in future versions + * + * Close WebSocket connection, disconnect listeners and reconnect observers + * + * @example + * await events.closeAll() + * + * @returns void on success + * @throws on error + */ +async function closeAll(): Promise { + await eventProvider.close(); } export { connect, post, closeAll }; From 4458d3069516d49dcd9268be1a45f2b9a720a020 Mon Sep 17 00:00:00 2001 From: Ivan Artemiev <29709626+iartemiev@users.noreply.github.com> Date: Wed, 6 Nov 2024 14:55:18 -0500 Subject: [PATCH 07/18] refactor(api-graphql): apply WS.close to base class (#13991) --- .../AWSAppSyncEventsProvider/index.ts | 21 ------------------- .../Providers/AWSWebSocketProvider/index.ts | 18 ++++++++++++++++ 2 files changed, 18 insertions(+), 21 deletions(-) diff --git a/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts b/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts index 859f69fcde6..eff48289acc 100644 --- a/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts +++ b/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts @@ -53,27 +53,6 @@ export class AWSAppSyncEventProvider extends AWSWebSocketProvider { return PROVIDER_NAME; } - close() { - return new Promise((resolve, reject) => { - super.close(); - if (this.awsRealTimeSocket) { - this.awsRealTimeSocket.onclose = (_: CloseEvent) => { - this.subscriptionObserverMap = new Map(); - this.awsRealTimeSocket = undefined; - resolve(); - }; - - this.awsRealTimeSocket.onerror = (err: any) => { - reject(err); - }; - - this.awsRealTimeSocket.close(); - } else { - resolve(); - } - }); - } - public async connect(options: AWSAppSyncEventProviderOptions) { super.connect(options); } diff --git a/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts b/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts index 4a5e0d8f3b0..6d60e30316e 100644 --- a/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts +++ b/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts @@ -112,6 +112,24 @@ export abstract class AWSWebSocketProvider { this.connectionStateMonitorSubscription.unsubscribe(); // Complete all reconnect observers this.reconnectionMonitor.close(); + + return new Promise((resolve, reject) => { + if (this.awsRealTimeSocket) { + this.awsRealTimeSocket.onclose = (_: CloseEvent) => { + this.subscriptionObserverMap = new Map(); + this.awsRealTimeSocket = undefined; + resolve(); + }; + + this.awsRealTimeSocket.onerror = (err: any) => { + reject(err); + }; + + this.awsRealTimeSocket.close(); + } else { + resolve(); + } + }); } subscribe( From 0f5091780046b9556b98300c29fb970a0358bd70 Mon Sep 17 00:00:00 2001 From: Chris Womack <67726635+cwomack@users.noreply.github.com> Date: Fri, 8 Nov 2024 13:28:54 -0700 Subject: [PATCH 08/18] fix(core): Check for storage initialization errors (#13938) * fix(core): Check for storage initialization errors * address nits and add logger * fixed unit test errors * bundle size fixes * implementing feedback Co-authored-by: AllanZhengYP --------- Co-authored-by: AllanZhengYP --- packages/aws-amplify/package.json | 6 +-- .../__tests__/storage/DefaultStorage.test.ts | 22 +++++++++ .../__tests__/storage/SessionStorage.test.ts | 24 +++++++++- packages/core/package.json | 2 +- packages/core/src/storage/utils.ts | 45 +++++++++++++++---- 5 files changed, 86 insertions(+), 13 deletions(-) diff --git a/packages/aws-amplify/package.json b/packages/aws-amplify/package.json index e45fedb59ee..85b35c407d4 100644 --- a/packages/aws-amplify/package.json +++ b/packages/aws-amplify/package.json @@ -293,7 +293,7 @@ "name": "[Analytics] record (Pinpoint)", "path": "./dist/esm/analytics/index.mjs", "import": "{ record }", - "limit": "17.41 kB" + "limit": "17.5 kB" }, { "name": "[Analytics] record (Kinesis)", @@ -317,7 +317,7 @@ "name": "[Analytics] identifyUser (Pinpoint)", "path": "./dist/esm/analytics/index.mjs", "import": "{ identifyUser }", - "limit": "15.91 kB" + "limit": "15.95 kB" }, { "name": "[Analytics] enable", @@ -497,7 +497,7 @@ "name": "[Storage] uploadData (S3)", "path": "./dist/esm/storage/index.mjs", "import": "{ uploadData }", - "limit": "20.08 kB" + "limit": "20.15 kB" } ] } diff --git a/packages/core/__tests__/storage/DefaultStorage.test.ts b/packages/core/__tests__/storage/DefaultStorage.test.ts index 47214d899d7..519adb01af9 100644 --- a/packages/core/__tests__/storage/DefaultStorage.test.ts +++ b/packages/core/__tests__/storage/DefaultStorage.test.ts @@ -1,4 +1,5 @@ import { DefaultStorage } from '../../src/storage/DefaultStorage'; +import { InMemoryStorage } from '../../src/storage/InMemoryStorage'; const key = 'k'; const value = 'value'; @@ -35,4 +36,25 @@ describe('DefaultStorage', () => { await defaultStorage.clear(); expect(defaultStorage.getItem(key)).resolves.toBeNull(); }); + + it('should fall back to alternative storage when localStorage is not accessible', async () => { + // Mock window.localStorage to throw an error + const originalLocalStorage = window.localStorage; + + Object.defineProperty(window, 'localStorage', { + value: undefined, + writable: true, + }); + + // Create a new DefaultStorage instance to trigger the fallback + const fallbackStorage = new DefaultStorage(); + + // Verify that the storage still works as expected + expect(fallbackStorage.storage instanceof InMemoryStorage).toEqual(true); + + // Restore the original localStorage + Object.defineProperty(window, 'localStorage', { + value: originalLocalStorage, + }); + }); }); diff --git a/packages/core/__tests__/storage/SessionStorage.test.ts b/packages/core/__tests__/storage/SessionStorage.test.ts index df6116d823e..81545838f12 100644 --- a/packages/core/__tests__/storage/SessionStorage.test.ts +++ b/packages/core/__tests__/storage/SessionStorage.test.ts @@ -1,9 +1,10 @@ +import { InMemoryStorage } from '../../src/storage/InMemoryStorage'; import { SessionStorage } from '../../src/storage/SessionStorage'; const key = 'k'; const value = 'value'; -describe('sessionStorage', () => { +describe('SessionStorage', () => { let sessionStorage: SessionStorage; beforeEach(() => { @@ -37,4 +38,25 @@ describe('sessionStorage', () => { await sessionStorage.clear(); expect(await sessionStorage.getItem(key)).toBeNull(); }); + + it('should fall back to alternative storage when sessionStorage is not accessible', async () => { + // Mock window.sessionStorage to throw an error + const originalSessionStorage = window.sessionStorage; + + Object.defineProperty(window, 'sessionStorage', { + value: undefined, + writable: true, + }); + + // Create a new SessionStorage instance to trigger the fallback + const fallbackStorage = new SessionStorage(); + + // Verify that the storage still works as expected + expect(fallbackStorage.storage instanceof InMemoryStorage).toEqual(true); + + // Restore the original sessionStorage + Object.defineProperty(window, 'sessionStorage', { + value: originalSessionStorage, + }); + }); }); diff --git a/packages/core/package.json b/packages/core/package.json index 1161de3d320..12d291faa59 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -106,7 +106,7 @@ "name": "Cache (default browser storage)", "path": "./dist/esm/index.mjs", "import": "{ Cache }", - "limit": "3.3 kB" + "limit": "3.4 kB" } ], "exports": { diff --git a/packages/core/src/storage/utils.ts b/packages/core/src/storage/utils.ts index 527d91d7f4e..8307f205917 100644 --- a/packages/core/src/storage/utils.ts +++ b/packages/core/src/storage/utils.ts @@ -1,22 +1,51 @@ // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. // SPDX-License-Identifier: Apache-2.0 +import { ConsoleLogger } from '../Logger'; + import { InMemoryStorage } from './InMemoryStorage'; /** * @internal * @returns Either a reference to window.localStorage or an in-memory storage as fallback */ -export const getLocalStorageWithFallback = (): Storage => - typeof window !== 'undefined' && window.localStorage - ? window.localStorage - : new InMemoryStorage(); + +const logger = new ConsoleLogger('CoreStorageUtils'); + +export const getLocalStorageWithFallback = (): Storage => { + try { + // Attempt to use localStorage directly + if (typeof window !== 'undefined' && window.localStorage) { + return window.localStorage; + } + } catch (e) { + // Handle any errors related to localStorage access + logger.error('LocalStorage access failed:', e); + } + + // Return in-memory storage as a fallback if localStorage is not accessible + return new InMemoryStorage(); +}; /** * @internal * @returns Either a reference to window.sessionStorage or an in-memory storage as fallback */ -export const getSessionStorageWithFallback = (): Storage => - typeof window !== 'undefined' && window.sessionStorage - ? window.sessionStorage - : new InMemoryStorage(); +export const getSessionStorageWithFallback = (): Storage => { + try { + // Attempt to use sessionStorage directly + if (typeof window !== 'undefined' && window.sessionStorage) { + // Verify we can actually use it by testing access + window.sessionStorage.getItem('test'); + + return window.sessionStorage; + } + + throw new Error('sessionStorage is not defined'); + } catch (e) { + // Handle any errors related to sessionStorage access + logger.error('SessionStorage access failed:', e); + + return new InMemoryStorage(); + } +}; From 460627966350c67db890dd908e882885e93624a7 Mon Sep 17 00:00:00 2001 From: Ivan Artemiev <29709626+iartemiev@users.noreply.github.com> Date: Tue, 12 Nov 2024 15:45:57 -0500 Subject: [PATCH 09/18] fix(api-graphql): events ws connect sig (#14003) --- .../src/Providers/AWSAppSyncEventsProvider/index.ts | 10 +++++++--- .../src/Providers/AWSAppSyncRealTimeProvider/index.ts | 7 ++++++- .../src/Providers/AWSWebSocketProvider/index.ts | 5 ++++- 3 files changed, 17 insertions(+), 5 deletions(-) diff --git a/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts b/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts index eff48289acc..214de3b92f4 100644 --- a/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts +++ b/packages/api-graphql/src/Providers/AWSAppSyncEventsProvider/index.ts @@ -43,10 +43,15 @@ interface DataResponse { const PROVIDER_NAME = 'AWSAppSyncEventsProvider'; const WS_PROTOCOL_NAME = 'aws-appsync-event-ws'; +const CONNECT_URI = ''; // events does not expect a connect uri export class AWSAppSyncEventProvider extends AWSWebSocketProvider { constructor() { - super({ providerName: PROVIDER_NAME, wsProtocolName: WS_PROTOCOL_NAME }); + super({ + providerName: PROVIDER_NAME, + wsProtocolName: WS_PROTOCOL_NAME, + connectUri: CONNECT_URI, + }); } getProviderName() { @@ -90,7 +95,6 @@ export class AWSAppSyncEventProvider extends AWSWebSocketProvider { appSyncGraphqlEndpoint, authenticationType, query, - variables, apiKey, region, } = options; @@ -100,7 +104,7 @@ export class AWSAppSyncEventProvider extends AWSWebSocketProvider { // events: [variables], // }; - const serializedData = JSON.stringify([variables]); + const serializedData = JSON.stringify({ channel: query }); const headers = { ...(await awsRealTimeHeaderBasedAuth({ diff --git a/packages/api-graphql/src/Providers/AWSAppSyncRealTimeProvider/index.ts b/packages/api-graphql/src/Providers/AWSAppSyncRealTimeProvider/index.ts index 2ba5968a890..084891b002b 100644 --- a/packages/api-graphql/src/Providers/AWSAppSyncRealTimeProvider/index.ts +++ b/packages/api-graphql/src/Providers/AWSAppSyncRealTimeProvider/index.ts @@ -42,10 +42,15 @@ interface DataPayload { const PROVIDER_NAME = 'AWSAppSyncRealTimeProvider'; const WS_PROTOCOL_NAME = 'graphql-ws'; +const CONNECT_URI = '/connect'; export class AWSAppSyncRealTimeProvider extends AWSWebSocketProvider { constructor() { - super({ providerName: PROVIDER_NAME, wsProtocolName: WS_PROTOCOL_NAME }); + super({ + providerName: PROVIDER_NAME, + wsProtocolName: WS_PROTOCOL_NAME, + connectUri: CONNECT_URI, + }); } getProviderName() { diff --git a/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts b/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts index 6d60e30316e..5d710e478bc 100644 --- a/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts +++ b/packages/api-graphql/src/Providers/AWSWebSocketProvider/index.ts @@ -74,6 +74,7 @@ interface ParsedMessagePayload { interface AWSWebSocketProviderArgs { providerName: string; wsProtocolName: string; + connectUri: string; } export abstract class AWSWebSocketProvider { @@ -91,10 +92,12 @@ export abstract class AWSWebSocketProvider { private readonly reconnectionMonitor = new ReconnectionMonitor(); private connectionStateMonitorSubscription: SubscriptionLike; private readonly wsProtocolName: string; + private readonly wsConnectUri: string; constructor(args: AWSWebSocketProviderArgs) { this.logger = new ConsoleLogger(args.providerName); this.wsProtocolName = args.wsProtocolName; + this.wsConnectUri = args.connectUri; this.connectionStateMonitorSubscription = this._startConnectionStateMonitoring(); @@ -739,7 +742,7 @@ export abstract class AWSWebSocketProvider { const authHeader = await awsRealTimeHeaderBasedAuth({ authenticationType, payload: payloadString, - canonicalUri: '/connect', + canonicalUri: this.wsConnectUri, apiKey, appSyncGraphqlEndpoint, region, From 72000ae3c10446cea3d3c4124770d9781fc6de59 Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Tue, 12 Nov 2024 23:40:24 +0000 Subject: [PATCH 10/18] chore(release): Set core metadata [skip release] --- packages/core/metadata | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/core/metadata b/packages/core/metadata index b011e9b696b..329d66f67ae 100644 --- a/packages/core/metadata +++ b/packages/core/metadata @@ -1 +1 @@ -e9f965729 +2797deb8a From cb245df21c532efdf7dba5b459a25f8456b0578f Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Tue, 12 Nov 2024 23:40:38 +0000 Subject: [PATCH 11/18] chore(release): Publish [skip release] - @aws-amplify/adapter-nextjs@1.2.27 - @aws-amplify/analytics@7.0.57 - @aws-amplify/api@6.1.2 - @aws-amplify/api-graphql@4.6.0 - @aws-amplify/api-rest@4.0.57 - @aws-amplify/auth@6.6.1 - aws-amplify@6.8.1 - @aws-amplify/core@6.5.2 - @aws-amplify/datastore@5.0.59 - @aws-amplify/datastore-storage-adapter@2.1.59 - @aws-amplify/geo@3.0.57 - @aws-amplify/interactions@6.0.56 - @aws-amplify/notifications@2.0.57 - @aws-amplify/predictions@6.1.32 - @aws-amplify/pubsub@6.1.32 - @aws-amplify/storage@6.6.15 - tsc-compliance-test@0.1.62 --- packages/adapter-nextjs/CHANGELOG.md | 4 ++++ packages/adapter-nextjs/package.json | 4 ++-- packages/analytics/CHANGELOG.md | 4 ++++ packages/analytics/package.json | 4 ++-- packages/api-graphql/CHANGELOG.md | 11 +++++++++++ packages/api-graphql/package.json | 6 +++--- packages/api-rest/CHANGELOG.md | 4 ++++ packages/api-rest/package.json | 4 ++-- packages/api/CHANGELOG.md | 4 ++++ packages/api/package.json | 6 +++--- packages/auth/CHANGELOG.md | 4 ++++ packages/auth/package.json | 4 ++-- packages/aws-amplify/CHANGELOG.md | 6 ++++++ packages/aws-amplify/package.json | 16 ++++++++-------- packages/core/CHANGELOG.md | 6 ++++++ packages/core/package.json | 2 +- packages/datastore-storage-adapter/CHANGELOG.md | 4 ++++ packages/datastore-storage-adapter/package.json | 6 +++--- packages/datastore/CHANGELOG.md | 4 ++++ packages/datastore/package.json | 6 +++--- packages/geo/CHANGELOG.md | 4 ++++ packages/geo/package.json | 4 ++-- packages/interactions/CHANGELOG.md | 4 ++++ packages/interactions/package.json | 4 ++-- packages/notifications/CHANGELOG.md | 4 ++++ packages/notifications/package.json | 4 ++-- packages/predictions/CHANGELOG.md | 4 ++++ packages/predictions/package.json | 6 +++--- packages/pubsub/CHANGELOG.md | 4 ++++ packages/pubsub/package.json | 6 +++--- packages/storage/CHANGELOG.md | 4 ++++ packages/storage/package.json | 4 ++-- scripts/tsc-compliance-test/CHANGELOG.md | 4 ++++ scripts/tsc-compliance-test/package.json | 4 ++-- 34 files changed, 124 insertions(+), 45 deletions(-) diff --git a/packages/adapter-nextjs/CHANGELOG.md b/packages/adapter-nextjs/CHANGELOG.md index 063570cf9b0..40cc70d24ab 100644 --- a/packages/adapter-nextjs/CHANGELOG.md +++ b/packages/adapter-nextjs/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [1.2.27](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/adapter-nextjs@1.2.26...@aws-amplify/adapter-nextjs@1.2.27) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/adapter-nextjs + ## [1.2.26](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/adapter-nextjs@1.2.25...@aws-amplify/adapter-nextjs@1.2.26) (2024-10-31) **Note:** Version bump only for package @aws-amplify/adapter-nextjs diff --git a/packages/adapter-nextjs/package.json b/packages/adapter-nextjs/package.json index 9ba39ecdb65..436226e8ed0 100644 --- a/packages/adapter-nextjs/package.json +++ b/packages/adapter-nextjs/package.json @@ -1,7 +1,7 @@ { "author": "Amazon Web Services", "name": "@aws-amplify/adapter-nextjs", - "version": "1.2.26", + "version": "1.2.27", "description": "The adapter for the supporting of using Amplify APIs in Next.js.", "peerDependencies": { "aws-amplify": "^6.0.7", @@ -16,7 +16,7 @@ "@types/node": "^20.3.1", "@types/react": "^18.2.13", "@types/react-dom": "^18.2.6", - "aws-amplify": "6.8.0", + "aws-amplify": "6.8.1", "jest-fetch-mock": "3.0.3", "next": ">= 13.5.0 < 15.0.0", "typescript": "5.0.2" diff --git a/packages/analytics/CHANGELOG.md b/packages/analytics/CHANGELOG.md index 59d4407226e..61205fc3f4c 100644 --- a/packages/analytics/CHANGELOG.md +++ b/packages/analytics/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [7.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/analytics@7.0.56...@aws-amplify/analytics@7.0.57) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/analytics + ## [7.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/analytics@7.0.55...@aws-amplify/analytics@7.0.56) (2024-10-31) **Note:** Version bump only for package @aws-amplify/analytics diff --git a/packages/analytics/package.json b/packages/analytics/package.json index 1594730cf8a..5f13d8d7566 100644 --- a/packages/analytics/package.json +++ b/packages/analytics/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/analytics", - "version": "7.0.56", + "version": "7.0.57", "description": "Analytics category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -103,7 +103,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "@aws-amplify/react-native": "1.1.6", "@aws-sdk/types": "3.398.0", "typescript": "5.0.2" diff --git a/packages/api-graphql/CHANGELOG.md b/packages/api-graphql/CHANGELOG.md index 18087e6f6f1..956c819f059 100644 --- a/packages/api-graphql/CHANGELOG.md +++ b/packages/api-graphql/CHANGELOG.md @@ -3,6 +3,17 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +# [4.6.0](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-graphql@4.5.1...@aws-amplify/api-graphql@4.6.0) (2024-11-12) + +### Bug Fixes + +- **api-graphql:** close WS on events.closeAll ([#13989](https://github.com/aws-amplify/amplify-js/issues/13989)) ([168ecff](https://github.com/aws-amplify/amplify-js/commit/168ecff80ede7c92a2a443471061237f250b1fcd)) +- **api-graphql:** events ws connect sig ([#14003](https://github.com/aws-amplify/amplify-js/issues/14003)) ([4606279](https://github.com/aws-amplify/amplify-js/commit/460627966350c67db890dd908e882885e93624a7)) + +### Features + +- **api-graphql:** return entire payload in callback ([#13980](https://github.com/aws-amplify/amplify-js/issues/13980)) ([d6eede3](https://github.com/aws-amplify/amplify-js/commit/d6eede3a68df1e6c49927e62ce0b73d6db615a8a)) + ## [4.5.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-graphql@4.5.0...@aws-amplify/api-graphql@4.5.1) (2024-10-31) **Note:** Version bump only for package @aws-amplify/api-graphql diff --git a/packages/api-graphql/package.json b/packages/api-graphql/package.json index 1d1486a9c16..42f350bdc6c 100644 --- a/packages/api-graphql/package.json +++ b/packages/api-graphql/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/api-graphql", - "version": "4.5.1", + "version": "4.6.0", "description": "Api-graphql category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -84,8 +84,8 @@ "server" ], "dependencies": { - "@aws-amplify/api-rest": "4.0.56", - "@aws-amplify/core": "6.5.1", + "@aws-amplify/api-rest": "4.0.57", + "@aws-amplify/core": "6.5.2", "@aws-amplify/data-schema": "^1.7.0", "@aws-sdk/types": "3.387.0", "graphql": "15.8.0", diff --git a/packages/api-rest/CHANGELOG.md b/packages/api-rest/CHANGELOG.md index b2554e6aa49..748e04e5e2a 100644 --- a/packages/api-rest/CHANGELOG.md +++ b/packages/api-rest/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [4.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-rest@4.0.56...@aws-amplify/api-rest@4.0.57) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/api-rest + ## [4.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-rest@4.0.55...@aws-amplify/api-rest@4.0.56) (2024-10-31) **Note:** Version bump only for package @aws-amplify/api-rest diff --git a/packages/api-rest/package.json b/packages/api-rest/package.json index 86e830d4964..117afd566b1 100644 --- a/packages/api-rest/package.json +++ b/packages/api-rest/package.json @@ -1,7 +1,7 @@ { "name": "@aws-amplify/api-rest", "private": false, - "version": "4.0.56", + "version": "4.0.57", "description": "Api-rest category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -87,7 +87,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" }, diff --git a/packages/api/CHANGELOG.md b/packages/api/CHANGELOG.md index b5e582ce527..09e9e814595 100644 --- a/packages/api/CHANGELOG.md +++ b/packages/api/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.2](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api@6.1.1...@aws-amplify/api@6.1.2) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/api + ## [6.1.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api@6.1.0...@aws-amplify/api@6.1.1) (2024-10-31) **Note:** Version bump only for package @aws-amplify/api diff --git a/packages/api/package.json b/packages/api/package.json index 5a0d531c69f..a66133be38b 100644 --- a/packages/api/package.json +++ b/packages/api/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/api", - "version": "6.1.1", + "version": "6.1.2", "description": "Api category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -79,8 +79,8 @@ "server" ], "dependencies": { - "@aws-amplify/api-graphql": "4.5.1", - "@aws-amplify/api-rest": "4.0.56", + "@aws-amplify/api-graphql": "4.6.0", + "@aws-amplify/api-rest": "4.0.57", "tslib": "^2.5.0" } } diff --git a/packages/auth/CHANGELOG.md b/packages/auth/CHANGELOG.md index d63deebe930..cc52bdd5573 100644 --- a/packages/auth/CHANGELOG.md +++ b/packages/auth/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.6.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/auth@6.6.0...@aws-amplify/auth@6.6.1) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/auth + # [6.6.0](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/auth@6.5.5...@aws-amplify/auth@6.6.0) (2024-10-31) ### Features diff --git a/packages/auth/package.json b/packages/auth/package.json index 5f6dddb0958..a8b70a30071 100644 --- a/packages/auth/package.json +++ b/packages/auth/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/auth", - "version": "6.6.0", + "version": "6.6.1", "description": "Auth category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -97,7 +97,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "@aws-amplify/react-native": "1.1.6", "@jest/test-sequencer": "^29.7.0", "typescript": "5.0.2" diff --git a/packages/aws-amplify/CHANGELOG.md b/packages/aws-amplify/CHANGELOG.md index 518fd1c590c..0a22ab52ea9 100644 --- a/packages/aws-amplify/CHANGELOG.md +++ b/packages/aws-amplify/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.8.1](https://github.com/aws-amplify/amplify-js/compare/aws-amplify@6.8.0...aws-amplify@6.8.1) (2024-11-12) + +### Bug Fixes + +- **core:** Check for storage initialization errors ([#13938](https://github.com/aws-amplify/amplify-js/issues/13938)) ([0f50917](https://github.com/aws-amplify/amplify-js/commit/0f5091780046b9556b98300c29fb970a0358bd70)) + # [6.8.0](https://github.com/aws-amplify/amplify-js/compare/aws-amplify@6.7.0...aws-amplify@6.8.0) (2024-10-31) ### Features diff --git a/packages/aws-amplify/package.json b/packages/aws-amplify/package.json index 85b35c407d4..8d612208830 100644 --- a/packages/aws-amplify/package.json +++ b/packages/aws-amplify/package.json @@ -1,6 +1,6 @@ { "name": "aws-amplify", - "version": "6.8.0", + "version": "6.8.1", "description": "AWS Amplify is a JavaScript library for Frontend and mobile developers building cloud-enabled applications.", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -276,13 +276,13 @@ "utils" ], "dependencies": { - "@aws-amplify/analytics": "7.0.56", - "@aws-amplify/api": "6.1.1", - "@aws-amplify/auth": "6.6.0", - "@aws-amplify/core": "6.5.1", - "@aws-amplify/datastore": "5.0.58", - "@aws-amplify/notifications": "2.0.56", - "@aws-amplify/storage": "6.6.14", + "@aws-amplify/analytics": "7.0.57", + "@aws-amplify/api": "6.1.2", + "@aws-amplify/auth": "6.6.1", + "@aws-amplify/core": "6.5.2", + "@aws-amplify/datastore": "5.0.59", + "@aws-amplify/notifications": "2.0.57", + "@aws-amplify/storage": "6.6.15", "tslib": "^2.5.0" }, "devDependencies": { diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md index 3008cb9c76c..a87bd17cdb3 100644 --- a/packages/core/CHANGELOG.md +++ b/packages/core/CHANGELOG.md @@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.5.2](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/core@6.5.1...@aws-amplify/core@6.5.2) (2024-11-12) + +### Bug Fixes + +- **core:** Check for storage initialization errors ([#13938](https://github.com/aws-amplify/amplify-js/issues/13938)) ([0f50917](https://github.com/aws-amplify/amplify-js/commit/0f5091780046b9556b98300c29fb970a0358bd70)) + ## [6.5.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/core@6.5.0...@aws-amplify/core@6.5.1) (2024-10-31) **Note:** Version bump only for package @aws-amplify/core diff --git a/packages/core/package.json b/packages/core/package.json index 12d291faa59..f858cdaf909 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/core", - "version": "6.5.1", + "version": "6.5.2", "description": "Core category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", diff --git a/packages/datastore-storage-adapter/CHANGELOG.md b/packages/datastore-storage-adapter/CHANGELOG.md index e67ee0e1f48..6141b05e559 100644 --- a/packages/datastore-storage-adapter/CHANGELOG.md +++ b/packages/datastore-storage-adapter/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [2.1.59](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore-storage-adapter@2.1.58...@aws-amplify/datastore-storage-adapter@2.1.59) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/datastore-storage-adapter + ## [2.1.58](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore-storage-adapter@2.1.57...@aws-amplify/datastore-storage-adapter@2.1.58) (2024-10-31) **Note:** Version bump only for package @aws-amplify/datastore-storage-adapter diff --git a/packages/datastore-storage-adapter/package.json b/packages/datastore-storage-adapter/package.json index 931a82be895..13d1487385e 100644 --- a/packages/datastore-storage-adapter/package.json +++ b/packages/datastore-storage-adapter/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/datastore-storage-adapter", - "version": "2.1.58", + "version": "2.1.59", "description": "SQLite storage adapter for Amplify DataStore ", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -36,8 +36,8 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", - "@aws-amplify/datastore": "5.0.58", + "@aws-amplify/core": "6.5.2", + "@aws-amplify/datastore": "5.0.59", "@types/react-native-sqlite-storage": "5.0.1", "expo-file-system": "13.1.4", "expo-sqlite": "10.1.0", diff --git a/packages/datastore/CHANGELOG.md b/packages/datastore/CHANGELOG.md index 2e7b6716df9..fabd2869d97 100644 --- a/packages/datastore/CHANGELOG.md +++ b/packages/datastore/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [5.0.59](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore@5.0.58...@aws-amplify/datastore@5.0.59) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/datastore + ## [5.0.58](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore@5.0.57...@aws-amplify/datastore@5.0.58) (2024-10-31) **Note:** Version bump only for package @aws-amplify/datastore diff --git a/packages/datastore/package.json b/packages/datastore/package.json index 5b4e7ec8a25..5613c09b7f1 100644 --- a/packages/datastore/package.json +++ b/packages/datastore/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/datastore", - "version": "5.0.58", + "version": "5.0.59", "description": "AppSyncLocal support for aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -44,7 +44,7 @@ "src" ], "dependencies": { - "@aws-amplify/api": "6.1.1", + "@aws-amplify/api": "6.1.2", "buffer": "4.9.2", "idb": "5.0.6", "immer": "9.0.6", @@ -55,7 +55,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "@aws-amplify/react-native": "1.1.6", "@types/uuid-validate": "^0.0.1", "dexie": "3.2.2", diff --git a/packages/geo/CHANGELOG.md b/packages/geo/CHANGELOG.md index 86d06731bf0..b2252522b29 100644 --- a/packages/geo/CHANGELOG.md +++ b/packages/geo/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [3.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/geo@3.0.56...@aws-amplify/geo@3.0.57) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/geo + ## [3.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/geo@3.0.55...@aws-amplify/geo@3.0.56) (2024-10-31) **Note:** Version bump only for package @aws-amplify/geo diff --git a/packages/geo/package.json b/packages/geo/package.json index 564838fef30..23aa84bd079 100644 --- a/packages/geo/package.json +++ b/packages/geo/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/geo", - "version": "3.0.56", + "version": "3.0.57", "description": "Geo category for aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -76,7 +76,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/interactions/CHANGELOG.md b/packages/interactions/CHANGELOG.md index 993850639b2..0de829c61f8 100644 --- a/packages/interactions/CHANGELOG.md +++ b/packages/interactions/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/interactions@6.0.55...@aws-amplify/interactions@6.0.56) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/interactions + ## [6.0.55](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/interactions@6.0.54...@aws-amplify/interactions@6.0.55) (2024-10-31) **Note:** Version bump only for package @aws-amplify/interactions diff --git a/packages/interactions/package.json b/packages/interactions/package.json index 02f0f5015b7..de930156be8 100644 --- a/packages/interactions/package.json +++ b/packages/interactions/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/interactions", - "version": "6.0.55", + "version": "6.0.56", "description": "Interactions category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -81,7 +81,7 @@ "uuid": "^9.0.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "typescript": "^5.0.2" }, "size-limit": [ diff --git a/packages/notifications/CHANGELOG.md b/packages/notifications/CHANGELOG.md index 91e2e473fa9..10c308ade52 100644 --- a/packages/notifications/CHANGELOG.md +++ b/packages/notifications/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [2.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/notifications@2.0.56...@aws-amplify/notifications@2.0.57) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/notifications + ## [2.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/notifications@2.0.55...@aws-amplify/notifications@2.0.56) (2024-10-31) **Note:** Version bump only for package @aws-amplify/notifications diff --git a/packages/notifications/package.json b/packages/notifications/package.json index 5354f3ae8ea..48784dce06e 100644 --- a/packages/notifications/package.json +++ b/packages/notifications/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/notifications", - "version": "2.0.56", + "version": "2.0.57", "description": "Notifications category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -98,7 +98,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" } diff --git a/packages/predictions/CHANGELOG.md b/packages/predictions/CHANGELOG.md index 3973ef20838..a3d1e8ecd06 100644 --- a/packages/predictions/CHANGELOG.md +++ b/packages/predictions/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.32](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/predictions@6.1.31...@aws-amplify/predictions@6.1.32) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/predictions + ## [6.1.31](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/predictions@6.1.30...@aws-amplify/predictions@6.1.31) (2024-10-31) **Note:** Version bump only for package @aws-amplify/predictions diff --git a/packages/predictions/package.json b/packages/predictions/package.json index 9ab00354ba6..c046ab2242b 100644 --- a/packages/predictions/package.json +++ b/packages/predictions/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/predictions", - "version": "6.1.31", + "version": "6.1.32", "description": "Machine learning category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -43,7 +43,7 @@ "src" ], "dependencies": { - "@aws-amplify/storage": "6.6.14", + "@aws-amplify/storage": "6.6.15", "@aws-sdk/client-comprehend": "3.621.0", "@aws-sdk/client-polly": "3.621.0", "@aws-sdk/client-rekognition": "3.621.0", @@ -59,7 +59,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/pubsub/CHANGELOG.md b/packages/pubsub/CHANGELOG.md index e1c4fe5410b..4449df17c17 100644 --- a/packages/pubsub/CHANGELOG.md +++ b/packages/pubsub/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.32](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/pubsub@6.1.31...@aws-amplify/pubsub@6.1.32) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/pubsub + ## [6.1.31](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/pubsub@6.1.30...@aws-amplify/pubsub@6.1.31) (2024-10-31) **Note:** Version bump only for package @aws-amplify/pubsub diff --git a/packages/pubsub/package.json b/packages/pubsub/package.json index 94864d07f32..6ae6e711050 100644 --- a/packages/pubsub/package.json +++ b/packages/pubsub/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/pubsub", - "version": "6.1.31", + "version": "6.1.32", "description": "Pubsub category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -73,7 +73,7 @@ "mqtt" ], "dependencies": { - "@aws-amplify/auth": "6.6.0", + "@aws-amplify/auth": "6.6.1", "buffer": "4.9.2", "graphql": "15.8.0", "rxjs": "^7.8.1", @@ -84,7 +84,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/storage/CHANGELOG.md b/packages/storage/CHANGELOG.md index 9c46a215ee4..8222d72cf68 100644 --- a/packages/storage/CHANGELOG.md +++ b/packages/storage/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.6.15](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/storage@6.6.14...@aws-amplify/storage@6.6.15) (2024-11-12) + +**Note:** Version bump only for package @aws-amplify/storage + ## [6.6.14](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/storage@6.6.13...@aws-amplify/storage@6.6.14) (2024-10-31) **Note:** Version bump only for package @aws-amplify/storage diff --git a/packages/storage/package.json b/packages/storage/package.json index 9f8fc60e413..e49959bf890 100644 --- a/packages/storage/package.json +++ b/packages/storage/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/storage", - "version": "6.6.14", + "version": "6.6.15", "description": "Storage category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -101,7 +101,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.1", + "@aws-amplify/core": "6.5.2", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" } diff --git a/scripts/tsc-compliance-test/CHANGELOG.md b/scripts/tsc-compliance-test/CHANGELOG.md index 864316eb13c..2c2f17a606d 100644 --- a/scripts/tsc-compliance-test/CHANGELOG.md +++ b/scripts/tsc-compliance-test/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [0.1.62](https://github.com/aws-amplify/amplify-js/compare/tsc-compliance-test@0.1.61...tsc-compliance-test@0.1.62) (2024-11-12) + +**Note:** Version bump only for package tsc-compliance-test + ## [0.1.61](https://github.com/aws-amplify/amplify-js/compare/tsc-compliance-test@0.1.60...tsc-compliance-test@0.1.61) (2024-10-31) **Note:** Version bump only for package tsc-compliance-test diff --git a/scripts/tsc-compliance-test/package.json b/scripts/tsc-compliance-test/package.json index 9211102a2a0..3cf3c8ee072 100644 --- a/scripts/tsc-compliance-test/package.json +++ b/scripts/tsc-compliance-test/package.json @@ -1,11 +1,11 @@ { "name": "tsc-compliance-test", - "version": "0.1.61", + "version": "0.1.62", "license": "MIT", "private": true, "devDependencies": { "@types/node": "16.18.82", - "aws-amplify": "6.8.0", + "aws-amplify": "6.8.1", "typescript": "4.2.x" }, "scripts": { From 7459b12f53eba9842774b21379550b1637c7f1ad Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Tue, 12 Nov 2024 23:42:02 +0000 Subject: [PATCH 12/18] chore(release): Update API docs [skip release] --- docs/api/functions/aws_amplify.api.events.closeAll.html | 8 +++++++- docs/api/modules/_aws_amplify_adapter_nextjs.html | 4 ++-- .../modules/_aws_amplify_datastore_storage_adapter.html | 4 ++-- docs/api/modules/_aws_amplify_geo.html | 4 ++-- docs/api/modules/_aws_amplify_interactions.html | 4 ++-- docs/api/modules/_aws_amplify_predictions.html | 4 ++-- docs/api/modules/_aws_amplify_pubsub.html | 4 ++-- docs/api/modules/aws_amplify.html | 4 ++-- 8 files changed, 21 insertions(+), 15 deletions(-) diff --git a/docs/api/functions/aws_amplify.api.events.closeAll.html b/docs/api/functions/aws_amplify.api.events.closeAll.html index cf81536db15..5123c908faf 100644 --- a/docs/api/functions/aws_amplify.api.events.closeAll.html +++ b/docs/api/functions/aws_amplify.api.events.closeAll.html @@ -1,2 +1,8 @@ closeAll | Amplify JS API Documentation -

Function closeAll

  • closeAll(): void

  • Returns void

Settings

Member Visibility

Theme

\ No newline at end of file +

Function closeAll

  • closeAll(): Promise<void>
  • Experimental

    API may change in future versions

    +

    Close WebSocket connection, disconnect listeners and reconnect observers

    +

    Returns Promise<void>

    void on success

    +

    Example

    await events.closeAll()
+
    +

    Throws

    on error

    +

Settings

Member Visibility

Theme

\ No newline at end of file diff --git a/docs/api/modules/_aws_amplify_adapter_nextjs.html b/docs/api/modules/_aws_amplify_adapter_nextjs.html index ceaadfb75bd..590588d35d3 100644 --- a/docs/api/modules/_aws_amplify_adapter_nextjs.html +++ b/docs/api/modules/_aws_amplify_adapter_nextjs.html @@ -1,5 +1,5 @@ -@aws-amplify/adapter-nextjs - v1.2.26 | Amplify JS API Documentation -

Module @aws-amplify/adapter-nextjs - v1.2.26

This package contains the AWS Amplify Next.js Adapter. For more information on using Next.js in your application please reference the Amplify Dev Center.

+@aws-amplify/adapter-nextjs - v1.2.27 | Amplify JS API Documentation +

Module @aws-amplify/adapter-nextjs - v1.2.27

This package contains the AWS Amplify Next.js Adapter. For more information on using Next.js in your application please reference the Amplify Dev Center.

Index

Modules

api index utils diff --git a/docs/api/modules/_aws_amplify_datastore_storage_adapter.html b/docs/api/modules/_aws_amplify_datastore_storage_adapter.html index 6e0bf8c3c8b..99f2738f07a 100644 --- a/docs/api/modules/_aws_amplify_datastore_storage_adapter.html +++ b/docs/api/modules/_aws_amplify_datastore_storage_adapter.html @@ -1,5 +1,5 @@ -@aws-amplify/datastore-storage-adapter - v2.1.58 | Amplify JS API Documentation -

Module @aws-amplify/datastore-storage-adapter - v2.1.58

This package contains the AWS Amplify DataStore storage adapter. For more information on using the DataStore storage adapter in your application please reference the Amplify Dev Center.

+@aws-amplify/datastore-storage-adapter - v2.1.59 | Amplify JS API Documentation +

Module @aws-amplify/datastore-storage-adapter - v2.1.59

This package contains the AWS Amplify DataStore storage adapter. For more information on using the DataStore storage adapter in your application please reference the Amplify Dev Center.

Index

Modules

ExpoSQLiteAdapter/ExpoSQLiteAdapter SQLiteAdapter/SQLiteAdapter index diff --git a/docs/api/modules/_aws_amplify_geo.html b/docs/api/modules/_aws_amplify_geo.html index 5fd4253860e..8758956199c 100644 --- a/docs/api/modules/_aws_amplify_geo.html +++ b/docs/api/modules/_aws_amplify_geo.html @@ -1,5 +1,5 @@ -@aws-amplify/geo - v3.0.56 | Amplify JS API Documentation -

Module @aws-amplify/geo - v3.0.56

This package contains the AWS Amplify Geo category. For more information on using Geo in your application please reference the Amplify Dev Center.

+@aws-amplify/geo - v3.0.57 | Amplify JS API Documentation +

Module @aws-amplify/geo - v3.0.57

This package contains the AWS Amplify Geo category. For more information on using Geo in your application please reference the Amplify Dev Center.

Index

Modules

index providers/location-service/AmazonLocationServiceProvider

Settings

Member Visibility

Theme

\ No newline at end of file diff --git a/docs/api/modules/_aws_amplify_interactions.html b/docs/api/modules/_aws_amplify_interactions.html index 4eee4562580..087578bebc4 100644 --- a/docs/api/modules/_aws_amplify_interactions.html +++ b/docs/api/modules/_aws_amplify_interactions.html @@ -1,5 +1,5 @@ -@aws-amplify/interactions - v6.0.55 | Amplify JS API Documentation -

Module @aws-amplify/interactions - v6.0.55

This package contains the AWS Amplify Interactions category. For more information on using Interactions in your application please reference the Amplify Dev Center.

+@aws-amplify/interactions - v6.0.56 | Amplify JS API Documentation +

Module @aws-amplify/interactions - v6.0.56

This package contains the AWS Amplify Interactions category. For more information on using Interactions in your application please reference the Amplify Dev Center.

Index

Modules

index lex-v1 lex-v2 diff --git a/docs/api/modules/_aws_amplify_predictions.html b/docs/api/modules/_aws_amplify_predictions.html index 261a1d51319..db5b890d033 100644 --- a/docs/api/modules/_aws_amplify_predictions.html +++ b/docs/api/modules/_aws_amplify_predictions.html @@ -1,5 +1,5 @@ -@aws-amplify/predictions - v6.1.31 | Amplify JS API Documentation -

Module @aws-amplify/predictions - v6.1.31

This package contains the AWS Amplify Predictions category. For more information on using Predictions in your application please reference the Amplify Dev Center.

+@aws-amplify/predictions - v6.1.32 | Amplify JS API Documentation +

Module @aws-amplify/predictions - v6.1.32

This package contains the AWS Amplify Predictions category. For more information on using Predictions in your application please reference the Amplify Dev Center.

Index

Modules

<Reference Types>

Interfaces

IdentifyEntitiesInput IdentifyEntitiesOutput diff --git a/docs/api/modules/_aws_amplify_pubsub.html b/docs/api/modules/_aws_amplify_pubsub.html index 93afe0854c0..4ebed696a49 100644 --- a/docs/api/modules/_aws_amplify_pubsub.html +++ b/docs/api/modules/_aws_amplify_pubsub.html @@ -1,5 +1,5 @@ -@aws-amplify/pubsub - v6.1.31 | Amplify JS API Documentation -

Module @aws-amplify/pubsub - v6.1.31

This package contains the AWS Amplify PubSub category. For more information on using PubSub in your application please reference the Amplify Dev Center.

+@aws-amplify/pubsub - v6.1.32 | Amplify JS API Documentation +

Module @aws-amplify/pubsub - v6.1.32

This package contains the AWS Amplify PubSub category. For more information on using PubSub in your application please reference the Amplify Dev Center.

Index

Modules

clients/iot clients/mqtt index diff --git a/docs/api/modules/aws_amplify.html b/docs/api/modules/aws_amplify.html index 8920ff975e0..a2af3694ec6 100644 --- a/docs/api/modules/aws_amplify.html +++ b/docs/api/modules/aws_amplify.html @@ -1,5 +1,5 @@ -aws-amplify - v6.8.0 | Amplify JS API Documentation -

Module aws-amplify - v6.8.0

AWS Amplify Package - aws-amplify

AWS Amplify is a JavaScript library for frontend and mobile developers building cloud-enabled applications. The library is a declarative interface across different categories of operations in order to make common tasks easier to add into your application. The default implementation works with Amazon Web Services (AWS) resources but is designed to be open and pluggable for usage with other cloud services that wish to provide an implementation or custom backends.

+aws-amplify - v6.8.1 | Amplify JS API Documentation +

Module aws-amplify - v6.8.1

AWS Amplify Package - aws-amplify

AWS Amplify is a JavaScript library for frontend and mobile developers building cloud-enabled applications. The library is a declarative interface across different categories of operations in order to make common tasks easier to add into your application. The default implementation works with Amazon Web Services (AWS) resources but is designed to be open and pluggable for usage with other cloud services that wish to provide an implementation or custom backends.

Documentation is available here.

Index

Modules

adapter-core analytics From c4d3d55bf54db670c2706f3e8aecedce35c28f2f Mon Sep 17 00:00:00 2001 From: yuhengshs Date: Wed, 13 Nov 2024 10:38:30 -0800 Subject: [PATCH 13/18] fix storage logger for storage initialization errors --- packages/core/polyfills/URL/index.js | 1 + packages/core/src/storage/utils.ts | 6 ++++-- 2 files changed, 5 insertions(+), 2 deletions(-) create mode 100644 packages/core/polyfills/URL/index.js diff --git a/packages/core/polyfills/URL/index.js b/packages/core/polyfills/URL/index.js new file mode 100644 index 00000000000..6745cf86f3f --- /dev/null +++ b/packages/core/polyfills/URL/index.js @@ -0,0 +1 @@ +(()=>{var e,r={515:e=>{"use strict";e.exports=require("react-native-url-polyfill/auto")}},o={},t={};"test"!==(null===(e=null===process||void 0===process?void 0:process.env)||void 0===e?void 0:e.NODE_ENV)&&function e(t){var s=o[t];if(void 0!==s)return s.exports;var i=o[t]={exports:{}};return r[t](i,i.exports,e),i.exports}(515);var s=exports;for(var i in t)s[i]=t[i];t.__esModule&&Object.defineProperty(s,"__esModule",{value:!0})})(); \ No newline at end of file diff --git a/packages/core/src/storage/utils.ts b/packages/core/src/storage/utils.ts index 8307f205917..dc639987c86 100644 --- a/packages/core/src/storage/utils.ts +++ b/packages/core/src/storage/utils.ts @@ -20,7 +20,7 @@ export const getLocalStorageWithFallback = (): Storage => { } } catch (e) { // Handle any errors related to localStorage access - logger.error('LocalStorage access failed:', e); + logger.info('localStorage access failed. InMemoryStorage is used as a fallback.'); } // Return in-memory storage as a fallback if localStorage is not accessible @@ -44,7 +44,9 @@ export const getSessionStorageWithFallback = (): Storage => { throw new Error('sessionStorage is not defined'); } catch (e) { // Handle any errors related to sessionStorage access - logger.error('SessionStorage access failed:', e); + logger.info( + 'sessionStorage access failed. InMemoryStorage is used as a fallback.', + ); return new InMemoryStorage(); } From 3cd66d6d9c4e33feb1ac57a1db69b2a7bc96f11e Mon Sep 17 00:00:00 2001 From: yuhengshs Date: Wed, 13 Nov 2024 10:55:28 -0800 Subject: [PATCH 14/18] address comments --- packages/aws-amplify/package.json | 4 ++-- packages/core/polyfills/URL/index.js | 1 - packages/core/src/storage/utils.ts | 6 ++++-- 3 files changed, 6 insertions(+), 5 deletions(-) delete mode 100644 packages/core/polyfills/URL/index.js diff --git a/packages/aws-amplify/package.json b/packages/aws-amplify/package.json index 8d612208830..55449c10653 100644 --- a/packages/aws-amplify/package.json +++ b/packages/aws-amplify/package.json @@ -317,7 +317,7 @@ "name": "[Analytics] identifyUser (Pinpoint)", "path": "./dist/esm/analytics/index.mjs", "import": "{ identifyUser }", - "limit": "15.95 kB" + "limit": "15.97 kB" }, { "name": "[Analytics] enable", @@ -497,7 +497,7 @@ "name": "[Storage] uploadData (S3)", "path": "./dist/esm/storage/index.mjs", "import": "{ uploadData }", - "limit": "20.15 kB" + "limit": "20.17 kB" } ] } diff --git a/packages/core/polyfills/URL/index.js b/packages/core/polyfills/URL/index.js deleted file mode 100644 index 6745cf86f3f..00000000000 --- a/packages/core/polyfills/URL/index.js +++ /dev/null @@ -1 +0,0 @@ -(()=>{var e,r={515:e=>{"use strict";e.exports=require("react-native-url-polyfill/auto")}},o={},t={};"test"!==(null===(e=null===process||void 0===process?void 0:process.env)||void 0===e?void 0:e.NODE_ENV)&&function e(t){var s=o[t];if(void 0!==s)return s.exports;var i=o[t]={exports:{}};return r[t](i,i.exports,e),i.exports}(515);var s=exports;for(var i in t)s[i]=t[i];t.__esModule&&Object.defineProperty(s,"__esModule",{value:!0})})(); \ No newline at end of file diff --git a/packages/core/src/storage/utils.ts b/packages/core/src/storage/utils.ts index dc639987c86..3d27578c839 100644 --- a/packages/core/src/storage/utils.ts +++ b/packages/core/src/storage/utils.ts @@ -20,7 +20,9 @@ export const getLocalStorageWithFallback = (): Storage => { } } catch (e) { // Handle any errors related to localStorage access - logger.info('localStorage access failed. InMemoryStorage is used as a fallback.'); + logger.info( + 'localStorage not found. InMemoryStorage is used as a fallback.', + ); } // Return in-memory storage as a fallback if localStorage is not accessible @@ -45,7 +47,7 @@ export const getSessionStorageWithFallback = (): Storage => { } catch (e) { // Handle any errors related to sessionStorage access logger.info( - 'sessionStorage access failed. InMemoryStorage is used as a fallback.', + 'sessionStorage not found. InMemoryStorage is used as a fallback.', ); return new InMemoryStorage(); From 8ca71fe7f100ad3f8b5f1e333738940b56bbbdef Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Wed, 13 Nov 2024 22:01:45 +0000 Subject: [PATCH 15/18] chore(release): Set core metadata [skip release] --- packages/core/metadata | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/core/metadata b/packages/core/metadata index 329d66f67ae..852adf07360 100644 --- a/packages/core/metadata +++ b/packages/core/metadata @@ -1 +1 @@ -2797deb8a +f6727c6df From 02b3769ac17b556b058d4b2856d543792c3a5e85 Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Wed, 13 Nov 2024 22:02:00 +0000 Subject: [PATCH 16/18] chore(release): Publish [skip release] - @aws-amplify/adapter-nextjs@1.2.28 - @aws-amplify/analytics@7.0.58 - @aws-amplify/api@6.1.3 - @aws-amplify/api-graphql@4.6.1 - @aws-amplify/api-rest@4.0.58 - @aws-amplify/auth@6.6.2 - aws-amplify@6.8.2 - @aws-amplify/core@6.5.3 - @aws-amplify/datastore@5.0.60 - @aws-amplify/datastore-storage-adapter@2.1.60 - @aws-amplify/geo@3.0.58 - @aws-amplify/interactions@6.0.57 - @aws-amplify/notifications@2.0.58 - @aws-amplify/predictions@6.1.33 - @aws-amplify/pubsub@6.1.33 - @aws-amplify/storage@6.6.16 - tsc-compliance-test@0.1.63 --- packages/adapter-nextjs/CHANGELOG.md | 4 ++++ packages/adapter-nextjs/package.json | 4 ++-- packages/analytics/CHANGELOG.md | 4 ++++ packages/analytics/package.json | 4 ++-- packages/api-graphql/CHANGELOG.md | 4 ++++ packages/api-graphql/package.json | 6 +++--- packages/api-rest/CHANGELOG.md | 4 ++++ packages/api-rest/package.json | 4 ++-- packages/api/CHANGELOG.md | 4 ++++ packages/api/package.json | 6 +++--- packages/auth/CHANGELOG.md | 4 ++++ packages/auth/package.json | 4 ++-- packages/aws-amplify/CHANGELOG.md | 4 ++++ packages/aws-amplify/package.json | 16 ++++++++-------- packages/core/CHANGELOG.md | 4 ++++ packages/core/package.json | 2 +- packages/datastore-storage-adapter/CHANGELOG.md | 4 ++++ packages/datastore-storage-adapter/package.json | 6 +++--- packages/datastore/CHANGELOG.md | 4 ++++ packages/datastore/package.json | 6 +++--- packages/geo/CHANGELOG.md | 4 ++++ packages/geo/package.json | 4 ++-- packages/interactions/CHANGELOG.md | 4 ++++ packages/interactions/package.json | 4 ++-- packages/notifications/CHANGELOG.md | 4 ++++ packages/notifications/package.json | 4 ++-- packages/predictions/CHANGELOG.md | 4 ++++ packages/predictions/package.json | 6 +++--- packages/pubsub/CHANGELOG.md | 4 ++++ packages/pubsub/package.json | 6 +++--- packages/storage/CHANGELOG.md | 4 ++++ packages/storage/package.json | 4 ++-- scripts/tsc-compliance-test/CHANGELOG.md | 4 ++++ scripts/tsc-compliance-test/package.json | 4 ++-- 34 files changed, 113 insertions(+), 45 deletions(-) diff --git a/packages/adapter-nextjs/CHANGELOG.md b/packages/adapter-nextjs/CHANGELOG.md index 40cc70d24ab..76e5eb6f3b2 100644 --- a/packages/adapter-nextjs/CHANGELOG.md +++ b/packages/adapter-nextjs/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [1.2.28](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/adapter-nextjs@1.2.27...@aws-amplify/adapter-nextjs@1.2.28) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/adapter-nextjs + ## [1.2.27](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/adapter-nextjs@1.2.26...@aws-amplify/adapter-nextjs@1.2.27) (2024-11-12) **Note:** Version bump only for package @aws-amplify/adapter-nextjs diff --git a/packages/adapter-nextjs/package.json b/packages/adapter-nextjs/package.json index 436226e8ed0..817cc953dc9 100644 --- a/packages/adapter-nextjs/package.json +++ b/packages/adapter-nextjs/package.json @@ -1,7 +1,7 @@ { "author": "Amazon Web Services", "name": "@aws-amplify/adapter-nextjs", - "version": "1.2.27", + "version": "1.2.28", "description": "The adapter for the supporting of using Amplify APIs in Next.js.", "peerDependencies": { "aws-amplify": "^6.0.7", @@ -16,7 +16,7 @@ "@types/node": "^20.3.1", "@types/react": "^18.2.13", "@types/react-dom": "^18.2.6", - "aws-amplify": "6.8.1", + "aws-amplify": "6.8.2", "jest-fetch-mock": "3.0.3", "next": ">= 13.5.0 < 15.0.0", "typescript": "5.0.2" diff --git a/packages/analytics/CHANGELOG.md b/packages/analytics/CHANGELOG.md index 61205fc3f4c..bd5c316ce8f 100644 --- a/packages/analytics/CHANGELOG.md +++ b/packages/analytics/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [7.0.58](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/analytics@7.0.57...@aws-amplify/analytics@7.0.58) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/analytics + ## [7.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/analytics@7.0.56...@aws-amplify/analytics@7.0.57) (2024-11-12) **Note:** Version bump only for package @aws-amplify/analytics diff --git a/packages/analytics/package.json b/packages/analytics/package.json index 5f13d8d7566..d1841990828 100644 --- a/packages/analytics/package.json +++ b/packages/analytics/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/analytics", - "version": "7.0.57", + "version": "7.0.58", "description": "Analytics category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -103,7 +103,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "@aws-amplify/react-native": "1.1.6", "@aws-sdk/types": "3.398.0", "typescript": "5.0.2" diff --git a/packages/api-graphql/CHANGELOG.md b/packages/api-graphql/CHANGELOG.md index 956c819f059..db3c781dbbd 100644 --- a/packages/api-graphql/CHANGELOG.md +++ b/packages/api-graphql/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [4.6.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-graphql@4.6.0...@aws-amplify/api-graphql@4.6.1) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/api-graphql + # [4.6.0](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-graphql@4.5.1...@aws-amplify/api-graphql@4.6.0) (2024-11-12) ### Bug Fixes diff --git a/packages/api-graphql/package.json b/packages/api-graphql/package.json index 42f350bdc6c..aec2e00ff54 100644 --- a/packages/api-graphql/package.json +++ b/packages/api-graphql/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/api-graphql", - "version": "4.6.0", + "version": "4.6.1", "description": "Api-graphql category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -84,8 +84,8 @@ "server" ], "dependencies": { - "@aws-amplify/api-rest": "4.0.57", - "@aws-amplify/core": "6.5.2", + "@aws-amplify/api-rest": "4.0.58", + "@aws-amplify/core": "6.5.3", "@aws-amplify/data-schema": "^1.7.0", "@aws-sdk/types": "3.387.0", "graphql": "15.8.0", diff --git a/packages/api-rest/CHANGELOG.md b/packages/api-rest/CHANGELOG.md index 748e04e5e2a..af0959cdb9e 100644 --- a/packages/api-rest/CHANGELOG.md +++ b/packages/api-rest/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [4.0.58](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-rest@4.0.57...@aws-amplify/api-rest@4.0.58) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/api-rest + ## [4.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api-rest@4.0.56...@aws-amplify/api-rest@4.0.57) (2024-11-12) **Note:** Version bump only for package @aws-amplify/api-rest diff --git a/packages/api-rest/package.json b/packages/api-rest/package.json index 117afd566b1..1a444c119fc 100644 --- a/packages/api-rest/package.json +++ b/packages/api-rest/package.json @@ -1,7 +1,7 @@ { "name": "@aws-amplify/api-rest", "private": false, - "version": "4.0.57", + "version": "4.0.58", "description": "Api-rest category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -87,7 +87,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" }, diff --git a/packages/api/CHANGELOG.md b/packages/api/CHANGELOG.md index 09e9e814595..f6726327d0a 100644 --- a/packages/api/CHANGELOG.md +++ b/packages/api/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.3](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api@6.1.2...@aws-amplify/api@6.1.3) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/api + ## [6.1.2](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/api@6.1.1...@aws-amplify/api@6.1.2) (2024-11-12) **Note:** Version bump only for package @aws-amplify/api diff --git a/packages/api/package.json b/packages/api/package.json index a66133be38b..5fe2429ee6f 100644 --- a/packages/api/package.json +++ b/packages/api/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/api", - "version": "6.1.2", + "version": "6.1.3", "description": "Api category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -79,8 +79,8 @@ "server" ], "dependencies": { - "@aws-amplify/api-graphql": "4.6.0", - "@aws-amplify/api-rest": "4.0.57", + "@aws-amplify/api-graphql": "4.6.1", + "@aws-amplify/api-rest": "4.0.58", "tslib": "^2.5.0" } } diff --git a/packages/auth/CHANGELOG.md b/packages/auth/CHANGELOG.md index cc52bdd5573..cae4c9caec1 100644 --- a/packages/auth/CHANGELOG.md +++ b/packages/auth/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.6.2](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/auth@6.6.1...@aws-amplify/auth@6.6.2) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/auth + ## [6.6.1](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/auth@6.6.0...@aws-amplify/auth@6.6.1) (2024-11-12) **Note:** Version bump only for package @aws-amplify/auth diff --git a/packages/auth/package.json b/packages/auth/package.json index a8b70a30071..42771efb06b 100644 --- a/packages/auth/package.json +++ b/packages/auth/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/auth", - "version": "6.6.1", + "version": "6.6.2", "description": "Auth category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -97,7 +97,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "@aws-amplify/react-native": "1.1.6", "@jest/test-sequencer": "^29.7.0", "typescript": "5.0.2" diff --git a/packages/aws-amplify/CHANGELOG.md b/packages/aws-amplify/CHANGELOG.md index 0a22ab52ea9..93361f07dab 100644 --- a/packages/aws-amplify/CHANGELOG.md +++ b/packages/aws-amplify/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.8.2](https://github.com/aws-amplify/amplify-js/compare/aws-amplify@6.8.1...aws-amplify@6.8.2) (2024-11-13) + +**Note:** Version bump only for package aws-amplify + ## [6.8.1](https://github.com/aws-amplify/amplify-js/compare/aws-amplify@6.8.0...aws-amplify@6.8.1) (2024-11-12) ### Bug Fixes diff --git a/packages/aws-amplify/package.json b/packages/aws-amplify/package.json index 55449c10653..9c05b6b9f25 100644 --- a/packages/aws-amplify/package.json +++ b/packages/aws-amplify/package.json @@ -1,6 +1,6 @@ { "name": "aws-amplify", - "version": "6.8.1", + "version": "6.8.2", "description": "AWS Amplify is a JavaScript library for Frontend and mobile developers building cloud-enabled applications.", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -276,13 +276,13 @@ "utils" ], "dependencies": { - "@aws-amplify/analytics": "7.0.57", - "@aws-amplify/api": "6.1.2", - "@aws-amplify/auth": "6.6.1", - "@aws-amplify/core": "6.5.2", - "@aws-amplify/datastore": "5.0.59", - "@aws-amplify/notifications": "2.0.57", - "@aws-amplify/storage": "6.6.15", + "@aws-amplify/analytics": "7.0.58", + "@aws-amplify/api": "6.1.3", + "@aws-amplify/auth": "6.6.2", + "@aws-amplify/core": "6.5.3", + "@aws-amplify/datastore": "5.0.60", + "@aws-amplify/notifications": "2.0.58", + "@aws-amplify/storage": "6.6.16", "tslib": "^2.5.0" }, "devDependencies": { diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md index a87bd17cdb3..4cf9badd0d1 100644 --- a/packages/core/CHANGELOG.md +++ b/packages/core/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.5.3](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/core@6.5.2...@aws-amplify/core@6.5.3) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/core + ## [6.5.2](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/core@6.5.1...@aws-amplify/core@6.5.2) (2024-11-12) ### Bug Fixes diff --git a/packages/core/package.json b/packages/core/package.json index f858cdaf909..7cfe8932f22 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/core", - "version": "6.5.2", + "version": "6.5.3", "description": "Core category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", diff --git a/packages/datastore-storage-adapter/CHANGELOG.md b/packages/datastore-storage-adapter/CHANGELOG.md index 6141b05e559..f40c5d42bb2 100644 --- a/packages/datastore-storage-adapter/CHANGELOG.md +++ b/packages/datastore-storage-adapter/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [2.1.60](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore-storage-adapter@2.1.59...@aws-amplify/datastore-storage-adapter@2.1.60) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/datastore-storage-adapter + ## [2.1.59](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore-storage-adapter@2.1.58...@aws-amplify/datastore-storage-adapter@2.1.59) (2024-11-12) **Note:** Version bump only for package @aws-amplify/datastore-storage-adapter diff --git a/packages/datastore-storage-adapter/package.json b/packages/datastore-storage-adapter/package.json index 13d1487385e..ca17c163092 100644 --- a/packages/datastore-storage-adapter/package.json +++ b/packages/datastore-storage-adapter/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/datastore-storage-adapter", - "version": "2.1.59", + "version": "2.1.60", "description": "SQLite storage adapter for Amplify DataStore ", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -36,8 +36,8 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", - "@aws-amplify/datastore": "5.0.59", + "@aws-amplify/core": "6.5.3", + "@aws-amplify/datastore": "5.0.60", "@types/react-native-sqlite-storage": "5.0.1", "expo-file-system": "13.1.4", "expo-sqlite": "10.1.0", diff --git a/packages/datastore/CHANGELOG.md b/packages/datastore/CHANGELOG.md index fabd2869d97..c265ab5711e 100644 --- a/packages/datastore/CHANGELOG.md +++ b/packages/datastore/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [5.0.60](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore@5.0.59...@aws-amplify/datastore@5.0.60) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/datastore + ## [5.0.59](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/datastore@5.0.58...@aws-amplify/datastore@5.0.59) (2024-11-12) **Note:** Version bump only for package @aws-amplify/datastore diff --git a/packages/datastore/package.json b/packages/datastore/package.json index 5613c09b7f1..f7463e9fbee 100644 --- a/packages/datastore/package.json +++ b/packages/datastore/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/datastore", - "version": "5.0.59", + "version": "5.0.60", "description": "AppSyncLocal support for aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -44,7 +44,7 @@ "src" ], "dependencies": { - "@aws-amplify/api": "6.1.2", + "@aws-amplify/api": "6.1.3", "buffer": "4.9.2", "idb": "5.0.6", "immer": "9.0.6", @@ -55,7 +55,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "@aws-amplify/react-native": "1.1.6", "@types/uuid-validate": "^0.0.1", "dexie": "3.2.2", diff --git a/packages/geo/CHANGELOG.md b/packages/geo/CHANGELOG.md index b2252522b29..4aa7b63e4dd 100644 --- a/packages/geo/CHANGELOG.md +++ b/packages/geo/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [3.0.58](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/geo@3.0.57...@aws-amplify/geo@3.0.58) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/geo + ## [3.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/geo@3.0.56...@aws-amplify/geo@3.0.57) (2024-11-12) **Note:** Version bump only for package @aws-amplify/geo diff --git a/packages/geo/package.json b/packages/geo/package.json index 23aa84bd079..84afbc1ed0e 100644 --- a/packages/geo/package.json +++ b/packages/geo/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/geo", - "version": "3.0.57", + "version": "3.0.58", "description": "Geo category for aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -76,7 +76,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/interactions/CHANGELOG.md b/packages/interactions/CHANGELOG.md index 0de829c61f8..ba6198c37dd 100644 --- a/packages/interactions/CHANGELOG.md +++ b/packages/interactions/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/interactions@6.0.56...@aws-amplify/interactions@6.0.57) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/interactions + ## [6.0.56](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/interactions@6.0.55...@aws-amplify/interactions@6.0.56) (2024-11-12) **Note:** Version bump only for package @aws-amplify/interactions diff --git a/packages/interactions/package.json b/packages/interactions/package.json index de930156be8..c6afad8222d 100644 --- a/packages/interactions/package.json +++ b/packages/interactions/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/interactions", - "version": "6.0.56", + "version": "6.0.57", "description": "Interactions category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -81,7 +81,7 @@ "uuid": "^9.0.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "typescript": "^5.0.2" }, "size-limit": [ diff --git a/packages/notifications/CHANGELOG.md b/packages/notifications/CHANGELOG.md index 10c308ade52..8a53f7eb202 100644 --- a/packages/notifications/CHANGELOG.md +++ b/packages/notifications/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [2.0.58](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/notifications@2.0.57...@aws-amplify/notifications@2.0.58) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/notifications + ## [2.0.57](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/notifications@2.0.56...@aws-amplify/notifications@2.0.57) (2024-11-12) **Note:** Version bump only for package @aws-amplify/notifications diff --git a/packages/notifications/package.json b/packages/notifications/package.json index 48784dce06e..05430066a13 100644 --- a/packages/notifications/package.json +++ b/packages/notifications/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/notifications", - "version": "2.0.57", + "version": "2.0.58", "description": "Notifications category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -98,7 +98,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" } diff --git a/packages/predictions/CHANGELOG.md b/packages/predictions/CHANGELOG.md index a3d1e8ecd06..0f3ab4a03d6 100644 --- a/packages/predictions/CHANGELOG.md +++ b/packages/predictions/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.33](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/predictions@6.1.32...@aws-amplify/predictions@6.1.33) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/predictions + ## [6.1.32](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/predictions@6.1.31...@aws-amplify/predictions@6.1.32) (2024-11-12) **Note:** Version bump only for package @aws-amplify/predictions diff --git a/packages/predictions/package.json b/packages/predictions/package.json index c046ab2242b..c972b675e20 100644 --- a/packages/predictions/package.json +++ b/packages/predictions/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/predictions", - "version": "6.1.32", + "version": "6.1.33", "description": "Machine learning category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -43,7 +43,7 @@ "src" ], "dependencies": { - "@aws-amplify/storage": "6.6.15", + "@aws-amplify/storage": "6.6.16", "@aws-sdk/client-comprehend": "3.621.0", "@aws-sdk/client-polly": "3.621.0", "@aws-sdk/client-rekognition": "3.621.0", @@ -59,7 +59,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/pubsub/CHANGELOG.md b/packages/pubsub/CHANGELOG.md index 4449df17c17..f197f2f5fd1 100644 --- a/packages/pubsub/CHANGELOG.md +++ b/packages/pubsub/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.1.33](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/pubsub@6.1.32...@aws-amplify/pubsub@6.1.33) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/pubsub + ## [6.1.32](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/pubsub@6.1.31...@aws-amplify/pubsub@6.1.32) (2024-11-12) **Note:** Version bump only for package @aws-amplify/pubsub diff --git a/packages/pubsub/package.json b/packages/pubsub/package.json index 6ae6e711050..3836690f391 100644 --- a/packages/pubsub/package.json +++ b/packages/pubsub/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/pubsub", - "version": "6.1.32", + "version": "6.1.33", "description": "Pubsub category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -73,7 +73,7 @@ "mqtt" ], "dependencies": { - "@aws-amplify/auth": "6.6.1", + "@aws-amplify/auth": "6.6.2", "buffer": "4.9.2", "graphql": "15.8.0", "rxjs": "^7.8.1", @@ -84,7 +84,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "typescript": "5.0.2" }, "size-limit": [ diff --git a/packages/storage/CHANGELOG.md b/packages/storage/CHANGELOG.md index 8222d72cf68..f5039e23a09 100644 --- a/packages/storage/CHANGELOG.md +++ b/packages/storage/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [6.6.16](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/storage@6.6.15...@aws-amplify/storage@6.6.16) (2024-11-13) + +**Note:** Version bump only for package @aws-amplify/storage + ## [6.6.15](https://github.com/aws-amplify/amplify-js/compare/@aws-amplify/storage@6.6.14...@aws-amplify/storage@6.6.15) (2024-11-12) **Note:** Version bump only for package @aws-amplify/storage diff --git a/packages/storage/package.json b/packages/storage/package.json index e49959bf890..2243eed63d1 100644 --- a/packages/storage/package.json +++ b/packages/storage/package.json @@ -1,6 +1,6 @@ { "name": "@aws-amplify/storage", - "version": "6.6.15", + "version": "6.6.16", "description": "Storage category of aws-amplify", "main": "./dist/cjs/index.js", "module": "./dist/esm/index.mjs", @@ -101,7 +101,7 @@ "@aws-amplify/core": "^6.1.0" }, "devDependencies": { - "@aws-amplify/core": "6.5.2", + "@aws-amplify/core": "6.5.3", "@aws-amplify/react-native": "1.1.6", "typescript": "5.0.2" } diff --git a/scripts/tsc-compliance-test/CHANGELOG.md b/scripts/tsc-compliance-test/CHANGELOG.md index 2c2f17a606d..c4e7343b5e4 100644 --- a/scripts/tsc-compliance-test/CHANGELOG.md +++ b/scripts/tsc-compliance-test/CHANGELOG.md @@ -3,6 +3,10 @@ All notable changes to this project will be documented in this file. See [Conventional Commits](https://conventionalcommits.org) for commit guidelines. +## [0.1.63](https://github.com/aws-amplify/amplify-js/compare/tsc-compliance-test@0.1.62...tsc-compliance-test@0.1.63) (2024-11-13) + +**Note:** Version bump only for package tsc-compliance-test + ## [0.1.62](https://github.com/aws-amplify/amplify-js/compare/tsc-compliance-test@0.1.61...tsc-compliance-test@0.1.62) (2024-11-12) **Note:** Version bump only for package tsc-compliance-test diff --git a/scripts/tsc-compliance-test/package.json b/scripts/tsc-compliance-test/package.json index 3cf3c8ee072..3d2f88e1a3a 100644 --- a/scripts/tsc-compliance-test/package.json +++ b/scripts/tsc-compliance-test/package.json @@ -1,11 +1,11 @@ { "name": "tsc-compliance-test", - "version": "0.1.62", + "version": "0.1.63", "license": "MIT", "private": true, "devDependencies": { "@types/node": "16.18.82", - "aws-amplify": "6.8.1", + "aws-amplify": "6.8.2", "typescript": "4.2.x" }, "scripts": { From 7d066ed1f297ff28631b63dfbd63209ba081d509 Mon Sep 17 00:00:00 2001 From: aws-amplify-bot Date: Wed, 13 Nov 2024 22:03:29 +0000 Subject: [PATCH 17/18] chore(release): Update API docs [skip release] --- docs/api/modules/_aws_amplify_adapter_nextjs.html | 4 ++-- docs/api/modules/_aws_amplify_datastore_storage_adapter.html | 4 ++-- docs/api/modules/_aws_amplify_geo.html | 4 ++-- docs/api/modules/_aws_amplify_interactions.html | 4 ++-- docs/api/modules/_aws_amplify_predictions.html | 4 ++-- docs/api/modules/_aws_amplify_pubsub.html | 4 ++-- docs/api/modules/aws_amplify.html | 4 ++-- 7 files changed, 14 insertions(+), 14 deletions(-) diff --git a/docs/api/modules/_aws_amplify_adapter_nextjs.html b/docs/api/modules/_aws_amplify_adapter_nextjs.html index 590588d35d3..1bd10844925 100644 --- a/docs/api/modules/_aws_amplify_adapter_nextjs.html +++ b/docs/api/modules/_aws_amplify_adapter_nextjs.html @@ -1,5 +1,5 @@ -@aws-amplify/adapter-nextjs - v1.2.27 | Amplify JS API Documentation -

Module @aws-amplify/adapter-nextjs - v1.2.27

This package contains the AWS Amplify Next.js Adapter. For more information on using Next.js in your application please reference the Amplify Dev Center.

+@aws-amplify/adapter-nextjs - v1.2.28 | Amplify JS API Documentation +

Module @aws-amplify/adapter-nextjs - v1.2.28

This package contains the AWS Amplify Next.js Adapter. For more information on using Next.js in your application please reference the Amplify Dev Center.

Index

Modules

api index utils diff --git a/docs/api/modules/_aws_amplify_datastore_storage_adapter.html b/docs/api/modules/_aws_amplify_datastore_storage_adapter.html index 99f2738f07a..41f76bb6b1c 100644 --- a/docs/api/modules/_aws_amplify_datastore_storage_adapter.html +++ b/docs/api/modules/_aws_amplify_datastore_storage_adapter.html @@ -1,5 +1,5 @@ -@aws-amplify/datastore-storage-adapter - v2.1.59 | Amplify JS API Documentation -

Module @aws-amplify/datastore-storage-adapter - v2.1.59

This package contains the AWS Amplify DataStore storage adapter. For more information on using the DataStore storage adapter in your application please reference the Amplify Dev Center.

+@aws-amplify/datastore-storage-adapter - v2.1.60 | Amplify JS API Documentation +

Module @aws-amplify/datastore-storage-adapter - v2.1.60

This package contains the AWS Amplify DataStore storage adapter. For more information on using the DataStore storage adapter in your application please reference the Amplify Dev Center.

Index

Modules

ExpoSQLiteAdapter/ExpoSQLiteAdapter SQLiteAdapter/SQLiteAdapter index diff --git a/docs/api/modules/_aws_amplify_geo.html b/docs/api/modules/_aws_amplify_geo.html index 8758956199c..72c076940ee 100644 --- a/docs/api/modules/_aws_amplify_geo.html +++ b/docs/api/modules/_aws_amplify_geo.html @@ -1,5 +1,5 @@ -@aws-amplify/geo - v3.0.57 | Amplify JS API Documentation -

Module @aws-amplify/geo - v3.0.57

This package contains the AWS Amplify Geo category. For more information on using Geo in your application please reference the Amplify Dev Center.

+@aws-amplify/geo - v3.0.58 | Amplify JS API Documentation +

Module @aws-amplify/geo - v3.0.58

This package contains the AWS Amplify Geo category. For more information on using Geo in your application please reference the Amplify Dev Center.

Index

Modules

index providers/location-service/AmazonLocationServiceProvider

Settings

Member Visibility

Theme

\ No newline at end of file diff --git a/docs/api/modules/_aws_amplify_interactions.html b/docs/api/modules/_aws_amplify_interactions.html index 087578bebc4..8fe216185a7 100644 --- a/docs/api/modules/_aws_amplify_interactions.html +++ b/docs/api/modules/_aws_amplify_interactions.html @@ -1,5 +1,5 @@ -@aws-amplify/interactions - v6.0.56 | Amplify JS API Documentation -

Module @aws-amplify/interactions - v6.0.56

This package contains the AWS Amplify Interactions category. For more information on using Interactions in your application please reference the Amplify Dev Center.

+@aws-amplify/interactions - v6.0.57 | Amplify JS API Documentation +

Module @aws-amplify/interactions - v6.0.57

This package contains the AWS Amplify Interactions category. For more information on using Interactions in your application please reference the Amplify Dev Center.

Index

Modules

index lex-v1 lex-v2 diff --git a/docs/api/modules/_aws_amplify_predictions.html b/docs/api/modules/_aws_amplify_predictions.html index db5b890d033..f80a61b8614 100644 --- a/docs/api/modules/_aws_amplify_predictions.html +++ b/docs/api/modules/_aws_amplify_predictions.html @@ -1,5 +1,5 @@ -@aws-amplify/predictions - v6.1.32 | Amplify JS API Documentation -

Module @aws-amplify/predictions - v6.1.32

This package contains the AWS Amplify Predictions category. For more information on using Predictions in your application please reference the Amplify Dev Center.

+@aws-amplify/predictions - v6.1.33 | Amplify JS API Documentation +

Module @aws-amplify/predictions - v6.1.33

This package contains the AWS Amplify Predictions category. For more information on using Predictions in your application please reference the Amplify Dev Center.

Index

Modules

<Reference Types>

Interfaces

IdentifyEntitiesInput IdentifyEntitiesOutput diff --git a/docs/api/modules/_aws_amplify_pubsub.html b/docs/api/modules/_aws_amplify_pubsub.html index 4ebed696a49..c184e6047d9 100644 --- a/docs/api/modules/_aws_amplify_pubsub.html +++ b/docs/api/modules/_aws_amplify_pubsub.html @@ -1,5 +1,5 @@ -@aws-amplify/pubsub - v6.1.32 | Amplify JS API Documentation -

Module @aws-amplify/pubsub - v6.1.32

This package contains the AWS Amplify PubSub category. For more information on using PubSub in your application please reference the Amplify Dev Center.

+@aws-amplify/pubsub - v6.1.33 | Amplify JS API Documentation +

Module @aws-amplify/pubsub - v6.1.33

This package contains the AWS Amplify PubSub category. For more information on using PubSub in your application please reference the Amplify Dev Center.

Index

Modules

clients/iot clients/mqtt index diff --git a/docs/api/modules/aws_amplify.html b/docs/api/modules/aws_amplify.html index a2af3694ec6..d9f234194a5 100644 --- a/docs/api/modules/aws_amplify.html +++ b/docs/api/modules/aws_amplify.html @@ -1,5 +1,5 @@ -aws-amplify - v6.8.1 | Amplify JS API Documentation -

Module aws-amplify - v6.8.1

AWS Amplify Package - aws-amplify

AWS Amplify is a JavaScript library for frontend and mobile developers building cloud-enabled applications. The library is a declarative interface across different categories of operations in order to make common tasks easier to add into your application. The default implementation works with Amazon Web Services (AWS) resources but is designed to be open and pluggable for usage with other cloud services that wish to provide an implementation or custom backends.

+aws-amplify - v6.8.2 | Amplify JS API Documentation +

Module aws-amplify - v6.8.2

AWS Amplify Package - aws-amplify

AWS Amplify is a JavaScript library for frontend and mobile developers building cloud-enabled applications. The library is a declarative interface across different categories of operations in order to make common tasks easier to add into your application. The default implementation works with Amazon Web Services (AWS) resources but is designed to be open and pluggable for usage with other cloud services that wish to provide an implementation or custom backends.

Documentation is available here.

Index

Modules

adapter-core analytics From af13e13608820a8f7dbea87b245ec7bb5f0e50cc Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Fri, 15 Nov 2024 15:21:47 -0800 Subject: [PATCH 18/18] chore(deps): bump @eslint/plugin-kit from 0.2.0 to 0.2.3 (#14015) Bumps [@eslint/plugin-kit](https://github.com/eslint/rewrite) from 0.2.0 to 0.2.3. - [Release notes](https://github.com/eslint/rewrite/releases) - [Changelog](https://github.com/eslint/rewrite/blob/main/release-please-config.json) - [Commits](https://github.com/eslint/rewrite/compare/core-v0.2.0...plugin-kit-v0.2.3) --- updated-dependencies: - dependency-name: "@eslint/plugin-kit" dependency-type: indirect ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- yarn.lock | 37 +++++++++++++++++++++++++++++++------ 1 file changed, 31 insertions(+), 6 deletions(-) diff --git a/yarn.lock b/yarn.lock index c2c865e8aad..e80146f785f 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2297,9 +2297,9 @@ integrity sha512-BsWiH1yFGjXXS2yvrf5LyuoSIIbPrGUWob917o+BTKuZ7qJdxX8aJLRxs1fS9n6r7vESrq1OUqb68dANcFXuQQ== "@eslint/plugin-kit@^0.2.0": - version "0.2.0" - resolved "https://registry.yarnpkg.com/@eslint/plugin-kit/-/plugin-kit-0.2.0.tgz#8712dccae365d24e9eeecb7b346f85e750ba343d" - integrity sha512-vH9PiIMMwvhCx31Af3HiGzsVNULDbyVkHXwlemn/B0TFj/00ho3y55efXrUZTfQipxoHC5u4xq6zblww1zm1Ig== + version "0.2.3" + resolved "https://registry.yarnpkg.com/@eslint/plugin-kit/-/plugin-kit-0.2.3.tgz#812980a6a41ecf3a8341719f92a6d1e784a2e0e8" + integrity sha512-2b/g5hRmpbb1o4GnTZax9N9m0FXzz9OV42ZzI4rDDMDuHUqigAiQCEWChBWCY4ztAGVRjoWT19v0yMmc5/L5kA== dependencies: levn "^0.4.1" @@ -14377,7 +14377,16 @@ string-length@^4.0.1: char-regex "^1.0.2" strip-ansi "^6.0.0" -"string-width-cjs@npm:string-width@^4.2.0", "string-width@^1.0.2 || 2 || 3 || 4", string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: +"string-width-cjs@npm:string-width@^4.2.0": + version "4.2.3" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== + dependencies: + emoji-regex "^8.0.0" + is-fullwidth-code-point "^3.0.0" + strip-ansi "^6.0.1" + +"string-width@^1.0.2 || 2 || 3 || 4", string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: version "4.2.3" resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== @@ -14455,7 +14464,7 @@ string_decoder@~1.1.1: dependencies: safe-buffer "~5.1.0" -"strip-ansi-cjs@npm:strip-ansi@^6.0.1", strip-ansi@^6.0.0, strip-ansi@^6.0.1: +"strip-ansi-cjs@npm:strip-ansi@^6.0.1": version "6.0.1" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== @@ -14469,6 +14478,13 @@ strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0: dependencies: ansi-regex "^4.1.0" +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== + dependencies: + ansi-regex "^5.0.1" + strip-ansi@^7.0.1, strip-ansi@^7.1.0: version "7.1.0" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45" @@ -15601,7 +15617,7 @@ wordwrap@^1.0.0: resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb" integrity sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q== -"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0: +"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0": version "7.0.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== @@ -15628,6 +15644,15 @@ wrap-ansi@^6.0.1, wrap-ansi@^6.2.0: string-width "^4.1.0" strip-ansi "^6.0.0" +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== + dependencies: + ansi-styles "^4.0.0" + string-width "^4.1.0" + strip-ansi "^6.0.0" + wrap-ansi@^8.1.0: version "8.1.0" resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-8.1.0.tgz#56dc22368ee570face1b49819975d9b9a5ead214"