chore(release): publish

- @standardnotes/[email protected].2
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].0
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].0
 - @standardnotes/[email protected].0
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].0
 - @standardnotes/[email protected].0
 - @standardnotes/[email protected].2
 - @standardnotes/[email protected].0

.github/workflows/desktop.release.reuse.yml

@@ -74,7 +74,7 @@ jobs:
       - name: Compile for AppImage
         run: yarn run webpack --config desktop.webpack.prod.js
       - name: AppImage
-        run: yarn run electron-builder --linux --x64 --ia32 -c.linux.target=AppImage --publish=never --c.extraMetadata.version=${{ env.APP_VERSION }}
+        run: yarn run electron-builder --linux --x64 -c.linux.target=AppImage --publish=never --c.extraMetadata.version=${{ env.APP_VERSION }}
       - name: AppImageX64
         run: yarn run electron-builder --linux --x64 -c.linux.target=AppImage --publish=never --c.extraMetadata.version=${{ env.APP_VERSION }}
       - name: AppImageArm64
@@ -83,7 +83,7 @@ jobs:
       - name: Deb
         run: |
           yarn run webpack --config desktop.webpack.prod.js --env deb
-          yarn run electron-builder --linux --x64 --ia32 -c.linux.target=deb --publish=never --c.extraMetadata.version=${{ env.APP_VERSION }}
+          yarn run electron-builder --linux --x64 -c.linux.target=deb --publish=never --c.extraMetadata.version=${{ env.APP_VERSION }}
       - name: DebArm64
         env:
           npm_config_target_arch: 'arm64'
@@ -180,12 +180,6 @@ jobs:
       - name: Generate Checksums
         run: node scripts/sums.mjs
 
-      - name: get-npm-version
-        id: package-version
-        uses: martinbeentjes/npm-get-version-action@main
-        with:
-          path: packages/desktop
-
       - name: Generate Release Notes
         uses: ./actions/release-notes
         with:

.github/workflows/desktop.windows.sign.yml

@@ -53,8 +53,3 @@ jobs:
         with:
           name: assets
           path: packages/desktop/dist
-      - name: get-npm-version
-        id: package-version
-        uses: martinbeentjes/npm-get-version-action@main
-        with:
-          path: packages/desktop

.github/workflows/mobile.release.prod.yml

@@ -43,12 +43,6 @@ jobs:
           lane: 'android prod'
           subdirectory: 'packages/mobile'
 
-      - name: get-npm-version
-        id: package-version
-        uses: martinbeentjes/npm-get-version-action@main
-        with:
-          path: packages/mobile
-
       - name: Generate Release Notes
         uses: ./actions/release-notes
         with:
@@ -60,8 +54,8 @@ jobs:
         uses: softprops/action-gh-release@v1
         with:
           token: ${{ secrets.CI_PAT_TOKEN }}
-          tag_name: "@standardnotes/mobile@${{ steps.package-version.outputs.current-version}}"
-          name: "Mobile ${{ steps.package-version.outputs.current-version }}"
+          tag_name: "@standardnotes/mobile@${{ env.PACKAGE_VERSION }}"
+          name: "Mobile ${{ env.PACKAGE_VERSION }}"
           body: ${{ steps.release-notes.outputs.result }}
           prerelease: true
           draft: false

.github/workflows/mobile.release.test.yml

@@ -42,12 +42,6 @@ jobs:
         with:
           lane: 'android dev'
           subdirectory: 'packages/mobile'
-
-      - name: get-npm-version
-        id: package-version
-        uses: martinbeentjes/npm-get-version-action@main
-        with:
-          path: packages/mobile
   ios:
     env:
       ITMSTRANSPORTER_FORCE_ITMS_PACKAGE_UPLOAD: true

.github/workflows/publish.yml

@@ -64,14 +64,14 @@ jobs:
 
       - name: Run E2E test suite
         if: "${{ contains(github.event.head_commit.message, 'skip e2e') == false }}"
-        uses: convictional/trigger-workflow-and-wait@v1.6.1
+        uses: convictional/trigger-workflow-and-wait@master
         with:
           owner: standardnotes
-          repo: e2e
+          repo: self-hosted
           github_token: ${{ secrets.CI_PAT_TOKEN }}
-          workflow_file_name: testing-with-stable-server.yml
+          workflow_file_name: testing-with-updating-client-and-server.yml
           wait_interval: 30
-          client_payload: '{"image_tag": "${{ github.sha }}"}'
+          client_payload: '{"snjs_image_tag": "${{ github.sha }}"}'
           propagate_failure: true
           trigger_workflow: true
           wait_workflow: true

.github/workflows/snjs.pr.yml

@@ -40,14 +40,14 @@ jobs:
           docker tag standardnotes/snjs:${{ github.sha }} standardnotes/snjs:test
           docker push standardnotes/snjs:test
       - name: Run E2E test suite
-        uses: convictional/trigger-workflow-and-wait@v1.6.1
+        uses: convictional/trigger-workflow-and-wait@master
         with:
           owner: standardnotes
-          repo: e2e
+          repo: self-hosted
           github_token: ${{ secrets.CI_PAT_TOKEN }}
-          workflow_file_name: testing-with-stable-server.yml
+          workflow_file_name: testing-with-updating-client-and-server.yml
           wait_interval: 30
-          client_payload: '{"image_tag": "${{ github.sha }}"}'
+          client_payload: '{"snjs_image_tag": "${{ github.sha }}"}'
           propagate_failure: true
           trigger_workflow: true
           wait_workflow: true

packages/api/CHANGELOG.md

@@ -3,6 +3,56 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.21.2](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-01-03)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.21.1](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-01-03)
+
+**Note:** Version bump only for package @standardnotes/api
+
+# [1.21.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-29)
+
+### Features
+
+* **api:** add authenticators api ([#2124](https://github.com/standardnotes/app/issues/2124)) ([59e8b5c](https://github.com/standardnotes/app/commit/59e8b5c8b5b61ef1cd8f291798c45860736a1296))
+
+## [1.20.26](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-29)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.25](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-28)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.24](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-27)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.23](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-27)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.22](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-21)
+
+### Bug Fixes
+
+* **api:** handling expired token responses ([#2113](https://github.com/standardnotes/app/issues/2113)) ([2696b07](https://github.com/standardnotes/app/commit/2696b07759104fb1d40781897f69e63133ad824a))
+
+## [1.20.21](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.20.20](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-19)
+
+### Bug Fixes
+
+* **snjs:** refreshing sessions ([#2106](https://github.com/standardnotes/app/issues/2106)) ([bb4f1ff](https://github.com/standardnotes/app/commit/bb4f1ff0990eb5a6f64e76a699fb95540cffdbb4))
+
+## [1.20.19](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-08)
+
+**Note:** Version bump only for package @standardnotes/api
+
 ## [1.20.18](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-12-05)
 
 **Note:** Version bump only for package @standardnotes/api

packages/api/jest.config.js

@@ -6,12 +6,4 @@ module.exports = {
   transform: {
     '^.+\\.tsx?$': ['ts-jest', { tsconfig: 'tsconfig.json' }],
   },
-  coverageThreshold: {
-    global: {
-      branches: 22,
-      functions: 69,
-      lines: 67,
-      statements: 67
-    }
-  }
 };

packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/api",
-  "version": "1.20.18",
+  "version": "1.21.2",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },
@@ -23,7 +23,7 @@
     "build": "tsc -p tsconfig.json",
     "lint": "eslint src --ext .ts",
     "lint:fix": "eslint src --ext .ts --fix",
-    "test": "jest spec --coverage"
+    "test": "jest spec --coverage --passWithNoTests"
   },
   "devDependencies": {
     "@types/jest": "^29.2.3",
@@ -37,6 +37,7 @@
   },
   "dependencies": {
     "@standardnotes/common": "^1.45.0",
+    "@standardnotes/domain-core": "^1.11.0",
     "@standardnotes/encryption": "workspace:*",
     "@standardnotes/models": "workspace:*",
     "@standardnotes/responses": "workspace:*",

packages/api/src/Domain/Client/Authenticator/AuthenticatorApiOperations.ts

@@ -0,0 +1,8 @@
+export enum AuthenticatorApiOperations {
+  List,
+  Delete,
+  GenerateRegistrationOptions,
+  GenerateAuthenticationOptions,
+  VerifyRegistrationResponse,
+  VerifyAuthenticationResponse,
+}

packages/api/src/Domain/Client/Authenticator/AuthenticatorApiService.ts

@@ -0,0 +1,152 @@
+import { ErrorMessage } from '../../Error/ErrorMessage'
+import { ApiCallError } from '../../Error/ApiCallError'
+
+import { AuthenticatorApiServiceInterface } from './AuthenticatorApiServiceInterface'
+import { AuthenticatorApiOperations } from './AuthenticatorApiOperations'
+import {
+  ListAuthenticatorsResponse,
+  DeleteAuthenticatorResponse,
+  GenerateAuthenticatorRegistrationOptionsResponse,
+  VerifyAuthenticatorRegistrationResponseResponse,
+  GenerateAuthenticatorAuthenticationOptionsResponse,
+  VerifyAuthenticatorAuthenticationResponseResponse,
+} from '../../Response'
+import { AuthenticatorServerInterface } from '../../Server/Authenticator/AuthenticatorServerInterface'
+
+export class AuthenticatorApiService implements AuthenticatorApiServiceInterface {
+  private operationsInProgress: Map<AuthenticatorApiOperations, boolean>
+
+  constructor(private authenticatorServer: AuthenticatorServerInterface) {
+    this.operationsInProgress = new Map()
+  }
+
+  async list(): Promise<ListAuthenticatorsResponse> {
+    if (this.operationsInProgress.get(AuthenticatorApiOperations.List)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(AuthenticatorApiOperations.List, true)
+
+    try {
+      const response = await this.authenticatorServer.list({})
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    } finally {
+      this.operationsInProgress.set(AuthenticatorApiOperations.List, false)
+    }
+  }
+
+  async delete(authenticatorId: string): Promise<DeleteAuthenticatorResponse> {
+    if (this.operationsInProgress.get(AuthenticatorApiOperations.Delete)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(AuthenticatorApiOperations.Delete, true)
+
+    try {
+      const response = await this.authenticatorServer.delete({
+        authenticatorId,
+      })
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    } finally {
+      this.operationsInProgress.set(AuthenticatorApiOperations.Delete, false)
+    }
+  }
+
+  async generateRegistrationOptions(
+    userUuid: string,
+    username: string,
+  ): Promise<GenerateAuthenticatorRegistrationOptionsResponse> {
+    if (this.operationsInProgress.get(AuthenticatorApiOperations.GenerateRegistrationOptions)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(AuthenticatorApiOperations.GenerateRegistrationOptions, true)
+
+    try {
+      const response = await this.authenticatorServer.generateRegistrationOptions({
+        username,
+        userUuid,
+      })
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    } finally {
+      this.operationsInProgress.set(AuthenticatorApiOperations.GenerateRegistrationOptions, false)
+    }
+  }
+
+  async verifyRegistrationResponse(
+    userUuid: string,
+    name: string,
+    registrationCredential: Record<string, unknown>,
+  ): Promise<VerifyAuthenticatorRegistrationResponseResponse> {
+    if (this.operationsInProgress.get(AuthenticatorApiOperations.VerifyRegistrationResponse)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(AuthenticatorApiOperations.VerifyRegistrationResponse, true)
+
+    try {
+      const response = await this.authenticatorServer.verifyRegistrationResponse({
+        userUuid,
+        name,
+        registrationCredential,
+      })
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    } finally {
+      this.operationsInProgress.set(AuthenticatorApiOperations.VerifyRegistrationResponse, false)
+    }
+  }
+
+  async generateAuthenticationOptions(): Promise<GenerateAuthenticatorAuthenticationOptionsResponse> {
+    if (this.operationsInProgress.get(AuthenticatorApiOperations.GenerateAuthenticationOptions)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(AuthenticatorApiOperations.GenerateAuthenticationOptions, true)
+
+    try {
+      const response = await this.authenticatorServer.generateAuthenticationOptions({})
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    } finally {
+      this.operationsInProgress.set(AuthenticatorApiOperations.GenerateAuthenticationOptions, false)
+    }
+  }
+
+  async verifyAuthenticationResponse(
+    userUuid: string,
+    authenticationCredential: Record<string, unknown>,
+  ): Promise<VerifyAuthenticatorAuthenticationResponseResponse> {
+    if (this.operationsInProgress.get(AuthenticatorApiOperations.VerifyAuthenticationResponse)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(AuthenticatorApiOperations.VerifyAuthenticationResponse, true)
+
+    try {
+      const response = await this.authenticatorServer.verifyAuthenticationResponse({
+        authenticationCredential,
+        userUuid,
+      })
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    } finally {
+      this.operationsInProgress.set(AuthenticatorApiOperations.VerifyAuthenticationResponse, false)
+    }
+  }
+}

packages/api/src/Domain/Client/Authenticator/AuthenticatorApiServiceInterface.ts

@@ -0,0 +1,27 @@
+import {
+  ListAuthenticatorsResponse,
+  DeleteAuthenticatorResponse,
+  GenerateAuthenticatorRegistrationOptionsResponse,
+  VerifyAuthenticatorRegistrationResponseResponse,
+  GenerateAuthenticatorAuthenticationOptionsResponse,
+  VerifyAuthenticatorAuthenticationResponseResponse,
+} from '../../Response'
+
+export interface AuthenticatorApiServiceInterface {
+  list(): Promise<ListAuthenticatorsResponse>
+  delete(authenticatorId: string): Promise<DeleteAuthenticatorResponse>
+  generateRegistrationOptions(
+    userUuid: string,
+    username: string,
+  ): Promise<GenerateAuthenticatorRegistrationOptionsResponse>
+  verifyRegistrationResponse(
+    userUuid: string,
+    name: string,
+    registrationCredential: Record<string, unknown>,
+  ): Promise<VerifyAuthenticatorRegistrationResponseResponse>
+  generateAuthenticationOptions(): Promise<GenerateAuthenticatorAuthenticationOptionsResponse>
+  verifyAuthenticationResponse(
+    userUuid: string,
+    authenticationCredential: Record<string, unknown>,
+  ): Promise<VerifyAuthenticatorAuthenticationResponseResponse>
+}

packages/api/src/Domain/Client/Subscription/SubscriptionApiService.spec.ts

@@ -1,211 +0,0 @@
-import { type Invitation } from '@standardnotes/models'
-
-import { SubscriptionInviteAcceptResponse } from '../../Response/Subscription/SubscriptionInviteAcceptResponse'
-import { SubscriptionInviteCancelResponse } from '../../Response/Subscription/SubscriptionInviteCancelResponse'
-import { SubscriptionInviteListResponse } from '../../Response/Subscription/SubscriptionInviteListResponse'
-import { SubscriptionInviteResponse } from '../../Response/Subscription/SubscriptionInviteResponse'
-import { SubscriptionServerInterface } from '../../Server/Subscription/SubscriptionServerInterface'
-
-import { SubscriptionApiOperations } from './SubscriptionApiOperations'
-import { SubscriptionApiService } from './SubscriptionApiService'
-
-describe('SubscriptionApiService', () => {
-  let subscriptionServer: SubscriptionServerInterface
-
-  const createService = () => new SubscriptionApiService(subscriptionServer)
-
-  beforeEach(() => {
-    subscriptionServer = {} as jest.Mocked<SubscriptionServerInterface>
-    subscriptionServer.invite = jest.fn().mockReturnValue({
-      data: { success: true, sharedSubscriptionInvitationUuid: '1-2-3' },
-    } as jest.Mocked<SubscriptionInviteResponse>)
-    subscriptionServer.cancelInvite = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<SubscriptionInviteCancelResponse>)
-    subscriptionServer.listInvites = jest.fn().mockReturnValue({
-      data: { invitations: [{} as jest.Mocked<Invitation>] },
-    } as jest.Mocked<SubscriptionInviteListResponse>)
-    subscriptionServer.acceptInvite = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<SubscriptionInviteAcceptResponse>)
-  })
-
-  it('should invite a user', async () => {
-    const response = await createService().invite('[email protected]')
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-        sharedSubscriptionInvitationUuid: '1-2-3',
-      },
-    })
-    expect(subscriptionServer.invite).toHaveBeenCalledWith({
-      api: '20200115',
-      identifier: '[email protected]',
-    })
-  })
-
-  it('should not invite a user if it is already inviting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[SubscriptionApiOperations.Inviting, true]]),
-    })
-
-    let error = null
-    try {
-      await service.invite('[email protected]')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not invite a user if the server fails', async () => {
-    subscriptionServer.invite = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().invite('[email protected]')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should cancel an invite', async () => {
-    const response = await createService().cancelInvite('1-2-3')
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-    expect(subscriptionServer.cancelInvite).toHaveBeenCalledWith({
-      api: '20200115',
-      inviteUuid: '1-2-3',
-    })
-  })
-
-  it('should not cancel an invite if it is already canceling', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[SubscriptionApiOperations.CancelingInvite, true]]),
-    })
-
-    let error = null
-    try {
-      await service.cancelInvite('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not cancel an invite if the server fails', async () => {
-    subscriptionServer.cancelInvite = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().cancelInvite('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should list invites', async () => {
-    const response = await createService().listInvites()
-
-    expect(response).toEqual({
-      data: {
-        invitations: [{} as jest.Mocked<Invitation>],
-      },
-    })
-    expect(subscriptionServer.listInvites).toHaveBeenCalledWith({
-      api: '20200115',
-    })
-  })
-
-  it('should not list invitations if it is already listing', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[SubscriptionApiOperations.ListingInvites, true]]),
-    })
-
-    let error = null
-    try {
-      await service.listInvites()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not list invites if the server fails', async () => {
-    subscriptionServer.listInvites = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().listInvites()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should accept an invite', async () => {
-    const response = await createService().acceptInvite('1-2-3')
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-    expect(subscriptionServer.acceptInvite).toHaveBeenCalledWith({
-      inviteUuid: '1-2-3',
-    })
-  })
-
-  it('should not accept an invite if it is already accepting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[SubscriptionApiOperations.AcceptingInvite, true]]),
-    })
-
-    let error = null
-    try {
-      await service.acceptInvite('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not accept an invite if the server fails', async () => {
-    subscriptionServer.acceptInvite = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().acceptInvite('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-})

packages/api/src/Domain/Client/User/UserApiService.spec.ts

@@ -1,197 +0,0 @@
-import { ProtocolVersion, UserRequestType } from '@standardnotes/common'
-import { type RootKeyParamsInterface } from '@standardnotes/models'
-import { UserDeletionResponse } from '../../Response/User/UserDeletionResponse'
-
-import { UserRegistrationResponse } from '../../Response/User/UserRegistrationResponse'
-import { UserRequestResponse } from '../../Response/UserRequest/UserRequestResponse'
-import { UserServerInterface } from '../../Server'
-import { UserRequestServerInterface } from '../../Server/UserRequest/UserRequestServerInterface'
-
-import { UserApiOperations } from './UserApiOperations'
-import { UserApiService } from './UserApiService'
-
-describe('UserApiService', () => {
-  let userServer: UserServerInterface
-  let userRequestServer: UserRequestServerInterface
-  let keyParams: RootKeyParamsInterface
-
-  const createService = () => new UserApiService(userServer, userRequestServer)
-
-  beforeEach(() => {
-    userServer = {} as jest.Mocked<UserServerInterface>
-    userServer.register = jest.fn().mockReturnValue({
-      data: { user: { email: '[email protected]', uuid: '1-2-3' } },
-    } as jest.Mocked<UserRegistrationResponse>)
-    userServer.deleteAccount = jest.fn().mockReturnValue({
-      data: { message: 'Success' },
-    } as jest.Mocked<UserDeletionResponse>)
-
-    userRequestServer = {} as jest.Mocked<UserRequestServerInterface>
-    userRequestServer.submitUserRequest = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<UserRequestResponse>)
-
-    keyParams = {} as jest.Mocked<RootKeyParamsInterface>
-    keyParams.getPortableValue = jest.fn().mockReturnValue({
-      identifier: '[email protected]',
-      version: ProtocolVersion.V004,
-    })
-  })
-
-  it('should register a user', async () => {
-    const response = await createService().register({
-      email: '[email protected]',
-      serverPassword: 'testpasswd',
-      keyParams,
-      ephemeral: false,
-    })
-
-    expect(response).toEqual({
-      data: {
-        user: {
-          email: '[email protected]',
-          uuid: '1-2-3',
-        },
-      },
-    })
-    expect(userServer.register).toHaveBeenCalledWith({
-      api: '20200115',
-      email: '[email protected]',
-      ephemeral: false,
-      identifier: '[email protected]',
-      password: 'testpasswd',
-      version: '004',
-    })
-  })
-
-  it('should not register a user if it is already registering', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[UserApiOperations.Registering, true]]),
-    })
-
-    let error = null
-    try {
-      await service.register({ email: '[email protected]', serverPassword: 'testpasswd', keyParams, ephemeral: false })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not register a user if the server fails', async () => {
-    userServer.register = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().register({
-        email: '[email protected]',
-        serverPassword: 'testpasswd',
-        keyParams,
-        ephemeral: false,
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should submit a user request', async () => {
-    const response = await createService().submitUserRequest({
-      userUuid: '1-2-3',
-      requestType: UserRequestType.ExitDiscount,
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-    expect(userRequestServer.submitUserRequest).toHaveBeenCalledWith({
-      userUuid: '1-2-3',
-      requestType: UserRequestType.ExitDiscount,
-    })
-  })
-
-  it('should not submit a user request if it is already submitting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[UserApiOperations.SubmittingRequest, true]]),
-    })
-
-    let error = null
-    try {
-      await service.submitUserRequest({ userUuid: '1-2-3', requestType: UserRequestType.ExitDiscount })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not submit a user request if the server fails', async () => {
-    userRequestServer.submitUserRequest = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().submitUserRequest({
-        userUuid: '1-2-3',
-        requestType: UserRequestType.ExitDiscount,
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should delete a user', async () => {
-    const response = await createService().deleteAccount('1-2-3')
-
-    expect(response).toEqual({
-      data: {
-        message: 'Success',
-      },
-    })
-    expect(userServer.deleteAccount).toHaveBeenCalledWith({
-      userUuid: '1-2-3',
-    })
-  })
-
-  it('should not delete a user if it is already deleting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[UserApiOperations.DeletingAccount, true]]),
-    })
-
-    let error = null
-    try {
-      await service.deleteAccount('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not delete a user if the server fails', async () => {
-    userServer.deleteAccount = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().deleteAccount('1-2-3')
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-})

packages/api/src/Domain/Client/WebSocket/WebSocketApiService.spec.ts

@@ -1,61 +0,0 @@
-import { WebSocketConnectionTokenResponse } from '../../Response'
-
-import { WebSocketServerInterface } from '../../Server/WebSocket/WebSocketServerInterface'
-import { WebSocketApiOperations } from './WebSocketApiOperations'
-
-import { WebSocketApiService } from './WebSocketApiService'
-
-describe('WebSocketApiService', () => {
-  let webSocketServer: WebSocketServerInterface
-
-  const createService = () => new WebSocketApiService(webSocketServer)
-
-  beforeEach(() => {
-    webSocketServer = {} as jest.Mocked<WebSocketServerInterface>
-    webSocketServer.createConnectionToken = jest.fn().mockReturnValue({
-      data: { token: 'foobar' },
-    } as jest.Mocked<WebSocketConnectionTokenResponse>)
-  })
-
-  it('should create a websocket connection token', async () => {
-    const response = await createService().createConnectionToken()
-
-    expect(response).toEqual({
-      data: {
-        token: 'foobar',
-      },
-    })
-    expect(webSocketServer.createConnectionToken).toHaveBeenCalledWith({})
-  })
-
-  it('should not create a token if it is already creating', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WebSocketApiOperations.CreatingConnectionToken, true]]),
-    })
-
-    let error = null
-    try {
-      await service.createConnectionToken()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not create a token if the server fails', async () => {
-    webSocketServer.createConnectionToken = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().createConnectionToken()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-})

packages/api/src/Domain/Client/Workspace/WorkspaceApiService.spec.ts

@@ -1,368 +0,0 @@
-import { WorkspaceAccessLevel, WorkspaceType } from '@standardnotes/common'
-
-import { HttpStatusCode } from '../../Http'
-import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
-import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
-import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
-import { WorkspaceListResponse } from '../../Response/Workspace/WorkspaceListResponse'
-import { WorkspaceUserListResponse } from '../../Response/Workspace/WorkspaceUserListResponse'
-import { WorkspaceServerInterface } from '../../Server/Workspace/WorkspaceServerInterface'
-import { WorkspaceKeyshareInitiatingResponse } from '../../Response/Workspace/WorkspaceKeyshareInitiatingResponse'
-
-import { WorkspaceApiOperations } from './WorkspaceApiOperations'
-import { WorkspaceApiService } from './WorkspaceApiService'
-
-describe('WorkspaceApiService', () => {
-  let workspaceServer: WorkspaceServerInterface
-
-  const createService = () => new WorkspaceApiService(workspaceServer)
-
-  beforeEach(() => {
-    workspaceServer = {} as jest.Mocked<WorkspaceServerInterface>
-    workspaceServer.createWorkspace = jest.fn().mockReturnValue({
-      data: { uuid: '1-2-3' },
-    } as jest.Mocked<WorkspaceCreationResponse>)
-    workspaceServer.inviteToWorkspace = jest.fn().mockReturnValue({
-      data: { uuid: 'i-1-2-3' },
-    } as jest.Mocked<WorkspaceInvitationResponse>)
-    workspaceServer.acceptInvite = jest.fn().mockReturnValue({
-      data: { success: true },
-    } as jest.Mocked<WorkspaceInvitationAcceptingResponse>)
-    workspaceServer.listWorkspaces = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { ownedWorkspaces: [], joinedWorkspaces: [] },
-    } as jest.Mocked<WorkspaceListResponse>)
-    workspaceServer.listWorkspaceUsers = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { users: [] },
-    } as jest.Mocked<WorkspaceUserListResponse>)
-    workspaceServer.initiateKeyshare = jest.fn().mockReturnValue({
-      status: HttpStatusCode.Success,
-      data: { success: true },
-    } as jest.Mocked<WorkspaceKeyshareInitiatingResponse>)
-  })
-
-  it('should create a workspace', async () => {
-    const response = await createService().createWorkspace({
-      workspaceType: WorkspaceType.Private,
-      encryptedPrivateKey: 'foo',
-      encryptedWorkspaceKey: 'bar',
-      publicKey: 'buzz',
-    })
-
-    expect(response).toEqual({
-      data: {
-        uuid: '1-2-3',
-      },
-    })
-    expect(workspaceServer.createWorkspace).toHaveBeenCalledWith({
-      encryptedPrivateKey: 'foo',
-      encryptedWorkspaceKey: 'bar',
-      publicKey: 'buzz',
-      workspaceType: 'private',
-    })
-  })
-
-  it('should not create a workspace if it is already creating', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.Creating, true]]),
-    })
-
-    let error = null
-    try {
-      await service.createWorkspace({
-        workspaceType: WorkspaceType.Private,
-        encryptedPrivateKey: 'foo',
-        encryptedWorkspaceKey: 'bar',
-        publicKey: 'buzz',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not create a workspace if the server fails', async () => {
-    workspaceServer.createWorkspace = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().createWorkspace({
-        workspaceType: WorkspaceType.Private,
-        encryptedPrivateKey: 'foo',
-        encryptedWorkspaceKey: 'bar',
-        publicKey: 'buzz',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should invite to a workspace', async () => {
-    const response = await createService().inviteToWorkspace({
-      workspaceUuid: 'w-1-2-3',
-      inviteeEmail: '[email protected]',
-      accessLevel: WorkspaceAccessLevel.WriteAndRead,
-    })
-
-    expect(response).toEqual({
-      data: {
-        uuid: 'i-1-2-3',
-      },
-    })
-    expect(workspaceServer.inviteToWorkspace).toHaveBeenCalledWith({
-      workspaceUuid: 'w-1-2-3',
-      inviteeEmail: '[email protected]',
-      accessLevel: 'write-and-read',
-    })
-  })
-
-  it('should not invite to a workspace if it is already inviting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.Inviting, true]]),
-    })
-
-    let error = null
-    try {
-      await service.inviteToWorkspace({
-        workspaceUuid: 'w-1-2-3',
-        inviteeEmail: '[email protected]',
-        accessLevel: WorkspaceAccessLevel.WriteAndRead,
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not invite to a workspace if the server fails', async () => {
-    workspaceServer.inviteToWorkspace = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().inviteToWorkspace({
-        workspaceUuid: 'w-1-2-3',
-        inviteeEmail: '[email protected]',
-        accessLevel: WorkspaceAccessLevel.WriteAndRead,
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should accept invite to a workspace', async () => {
-    const response = await createService().acceptInvite({
-      userUuid: 'u-1-2-3',
-      inviteUuid: 'i-1-2-3',
-      publicKey: 'foo',
-      encryptedPrivateKey: 'bar',
-    })
-
-    expect(response).toEqual({
-      data: {
-        success: true,
-      },
-    })
-    expect(workspaceServer.acceptInvite).toHaveBeenCalledWith({
-      userUuid: 'u-1-2-3',
-      inviteUuid: 'i-1-2-3',
-      publicKey: 'foo',
-      encryptedPrivateKey: 'bar',
-    })
-  })
-
-  it('should not accept invite to a workspace if it is already accepting', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.Accepting, true]]),
-    })
-
-    let error = null
-    try {
-      await service.acceptInvite({
-        userUuid: 'u-1-2-3',
-        inviteUuid: 'i-1-2-3',
-        publicKey: 'foo',
-        encryptedPrivateKey: 'bar',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not accept invite to a workspace if the server fails', async () => {
-    workspaceServer.acceptInvite = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().acceptInvite({
-        userUuid: 'u-1-2-3',
-        inviteUuid: 'i-1-2-3',
-        publicKey: 'foo',
-        encryptedPrivateKey: 'bar',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should list workspaces', async () => {
-    const response = await createService().listWorkspaces()
-
-    expect(response).toEqual({
-      status: 200,
-      data: {
-        ownedWorkspaces: [],
-        joinedWorkspaces: [],
-      },
-    })
-    expect(workspaceServer.listWorkspaces).toHaveBeenCalled()
-  })
-
-  it('should not list workspaces if it is already listing them', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.ListingWorkspaces, true]]),
-    })
-
-    let error = null
-    try {
-      await service.listWorkspaces()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not list workspaces if the server fails', async () => {
-    workspaceServer.listWorkspaces = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().listWorkspaces()
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should list workspace users', async () => {
-    const response = await createService().listWorkspaceUsers({ workspaceUuid: 'w-1-2-3' })
-
-    expect(response).toEqual({
-      status: 200,
-      data: {
-        users: [],
-      },
-    })
-    expect(workspaceServer.listWorkspaceUsers).toHaveBeenCalledWith({ workspaceUuid: 'w-1-2-3' })
-  })
-
-  it('should not list workspace users if it is already listing them', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.ListingWorkspaceUsers, true]]),
-    })
-
-    let error = null
-    try {
-      await service.listWorkspaceUsers({ workspaceUuid: 'w-1-2-3' })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not list workspace users if the server fails', async () => {
-    workspaceServer.listWorkspaceUsers = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().listWorkspaceUsers({ workspaceUuid: 'w-1-2-3' })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should initiate keyshare in workspace for user', async () => {
-    const response = await createService().initiateKeyshare({
-      workspaceUuid: 'w-1-2-3',
-      userUuid: 'u-1-2-3',
-      encryptedWorkspaceKey: 'foobar',
-    })
-
-    expect(response).toEqual({
-      status: 200,
-      data: {
-        success: true,
-      },
-    })
-    expect(workspaceServer.initiateKeyshare).toHaveBeenCalledWith({
-      workspaceUuid: 'w-1-2-3',
-      userUuid: 'u-1-2-3',
-      encryptedWorkspaceKey: 'foobar',
-    })
-  })
-
-  it('should not initiate keyshare in workspace if it is already initiating', async () => {
-    const service = createService()
-    Object.defineProperty(service, 'operationsInProgress', {
-      get: () => new Map([[WorkspaceApiOperations.InitiatingKeyshare, true]]),
-    })
-
-    let error = null
-    try {
-      await service.initiateKeyshare({ workspaceUuid: 'w-1-2-3', userUuid: 'u-1-2-3', encryptedWorkspaceKey: 'foobar' })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-
-  it('should not initiate keyshare in workspace if the server fails', async () => {
-    workspaceServer.initiateKeyshare = jest.fn().mockImplementation(() => {
-      throw new Error('Oops')
-    })
-
-    let error = null
-    try {
-      await createService().initiateKeyshare({
-        workspaceUuid: 'w-1-2-3',
-        userUuid: 'u-1-2-3',
-        encryptedWorkspaceKey: 'foobar',
-      })
-    } catch (caughtError) {
-      error = caughtError
-    }
-
-    expect(error).not.toBeNull()
-  })
-})

packages/api/src/Domain/Client/index.ts

@@ -1,3 +1,6 @@
+export * from './Authenticator/AuthenticatorApiOperations'
+export * from './Authenticator/AuthenticatorApiService'
+export * from './Authenticator/AuthenticatorApiServiceInterface'
 export * from './Subscription/SubscriptionApiOperations'
 export * from './Subscription/SubscriptionApiService'
 export * from './Subscription/SubscriptionApiServiceInterface'

packages/api/src/Domain/Http/HttpService.spec.ts

@@ -1,42 +0,0 @@
-import { Environment } from '@standardnotes/models'
-
-import { HttpResponseMeta } from './HttpResponseMeta'
-import { HttpService } from './HttpService'
-
-describe('HttpService', () => {
-  const environment = Environment.Web
-  const appVersion = '1.2.3'
-  const snjsVersion = '2.3.4'
-  const host = 'http://bar'
-  let updateMetaCallback: (meta: HttpResponseMeta) => void
-
-  const createService = () => {
-    const service = new HttpService(environment, appVersion, snjsVersion, updateMetaCallback)
-    service.setHost(host)
-    return service
-  }
-
-  beforeEach(() => {
-    updateMetaCallback = jest.fn()
-  })
-
-  it('should set host', () => {
-    const service = createService()
-
-    expect(service['host']).toEqual('http://bar')
-
-    service.setHost('http://foo')
-
-    expect(service['host']).toEqual('http://foo')
-  })
-
-  it('should set and use the authorization token', () => {
-    const service = createService()
-
-    expect(service['authorizationToken']).toBeUndefined()
-
-    service.setAuthorizationToken('foo-bar')
-
-    expect(service['authorizationToken']).toEqual('foo-bar')
-  })
-})

packages/api/src/Domain/Http/HttpService.ts

@@ -1,5 +1,7 @@
 import { isString, joinPaths, sleep } from '@standardnotes/utils'
 import { Environment } from '@standardnotes/models'
+import { Session, SessionToken } from '@standardnotes/domain-core'
+
 import { HttpRequestParams } from './HttpRequestParams'
 import { HttpVerb } from './HttpVerb'
 import { HttpRequest } from './HttpRequest'
@@ -10,21 +12,26 @@ import { XMLHttpRequestState } from './XMLHttpRequestState'
 import { ErrorMessage } from '../Error/ErrorMessage'
 import { HttpResponseMeta } from './HttpResponseMeta'
 import { HttpErrorResponseBody } from './HttpErrorResponseBody'
+import { Paths } from '../Server/Auth/Paths'
+import { SessionRefreshResponse } from '../Response/Auth/SessionRefreshResponse'
 
 export class HttpService implements HttpServiceInterface {
-  private authorizationToken?: string
+  private session: Session | null
   private __latencySimulatorMs?: number
-  private host!: string
+  private declare host: string
 
   constructor(
     private environment: Environment,
     private appVersion: string,
     private snjsVersion: string,
     private updateMetaCallback: (meta: HttpResponseMeta) => void,
-  ) {}
+    private refreshSessionCallback: (session: Session) => void,
+  ) {
+    this.session = null
+  }
 
-  setAuthorizationToken(authorizationToken: string): void {
-    this.authorizationToken = authorizationToken
+  setSession(session: Session): void {
+    this.session = session
   }
 
   setHost(host: string): void {
@@ -36,7 +43,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Get,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -45,7 +52,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Post,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -54,7 +61,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Put,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -63,7 +70,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Patch,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -72,7 +79,7 @@ export class HttpService implements HttpServiceInterface {
       url: joinPaths(this.host, path),
       params,
       verb: HttpVerb.Delete,
-      authentication: authentication ?? this.authorizationToken,
+      authentication: authentication ?? this.session?.accessToken.value,
     })
   }
 
@@ -89,9 +96,68 @@ export class HttpService implements HttpServiceInterface {
       this.updateMetaCallback(response.meta)
     }
 
+    if (response.status === HttpStatusCode.ExpiredAccessToken) {
+      const isSessionRefreshed = await this.refreshSession()
+      if (!isSessionRefreshed) {
+        return response
+      }
+
+      httpRequest.authentication = this.session?.accessToken.value
+
+      return this.runHttp(httpRequest)
+    }
+
     return response
   }
 
+  private async refreshSession(): Promise<boolean> {
+    if (this.session === null) {
+      return false
+    }
+
+    const response = (await this.post(Paths.v1.refreshSession, {
+      access_token: this.session.accessToken.value,
+      refresh_token: this.session.refreshToken.value,
+    })) as SessionRefreshResponse
+
+    if (response.data.error) {
+      return false
+    }
+
+    if (response.meta) {
+      this.updateMetaCallback(response.meta)
+    }
+
+    const accessTokenOrError = SessionToken.create(
+      response.data.session.access_token,
+      response.data.session.access_expiration,
+    )
+    if (accessTokenOrError.isFailed()) {
+      return false
+    }
+    const accessToken = accessTokenOrError.getValue()
+
+    const refreshTokenOrError = SessionToken.create(
+      response.data.session.refresh_token,
+      response.data.session.refresh_expiration,
+    )
+    if (refreshTokenOrError.isFailed()) {
+      return false
+    }
+    const refreshToken = refreshTokenOrError.getValue()
+
+    const sessionOrError = Session.create(accessToken, refreshToken, response.data.session.readonly_access)
+    if (sessionOrError.isFailed()) {
+      return false
+    }
+
+    this.setSession(sessionOrError.getValue())
+
+    this.refreshSessionCallback(this.session)
+
+    return true
+  }
+
   private createRequestBody(httpRequest: HttpRequest): string | Uint8Array | undefined {
     if (
       httpRequest.params !== undefined &&
@@ -199,13 +265,12 @@ export class HttpService implements HttpServiceInterface {
     } catch (error) {
       console.error(error)
     }
-    if (httpStatus >= HttpStatusCode.Success && httpStatus < HttpStatusCode.MultipleChoices) {
-      resolve(response)
-    } else {
+    if (httpStatus >= HttpStatusCode.Success && httpStatus < HttpStatusCode.InternalServerError) {
       if (httpStatus === HttpStatusCode.Forbidden && response.data && response.data.error !== undefined) {
         ;(response.data as HttpErrorResponseBody).error.message = ErrorMessage.RateLimited
       }
-
+      resolve(response)
+    } else {
       reject(response)
     }
   }

packages/api/src/Domain/Http/HttpServiceInterface.ts

@@ -1,9 +1,11 @@
+import { Session } from '@standardnotes/domain-core'
+
 import { HttpRequestParams } from './HttpRequestParams'
 import { HttpResponse } from './HttpResponse'
 
 export interface HttpServiceInterface {
   setHost(host: string): void
-  setAuthorizationToken(authorizationToken: string): void
+  setSession(session: Session): void
   get(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse>
   post(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse>
   put(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse>

packages/api/src/Domain/Http/HttpStatusCode.ts

@@ -7,4 +7,5 @@ export enum HttpStatusCode {
   Forbidden = 403,
   Gone = 410,
   ExpiredAccessToken = 498,
+  InternalServerError = 500,
 }

packages/api/src/Domain/Request/Authenticator/DeleteAuthenticatorRequestParams.ts

@@ -0,0 +1,4 @@
+export interface DeleteAuthenticatorRequestParams {
+  authenticatorId: string
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Authenticator/GenerateAuthenticatorAuthenticationOptionsRequestParams.ts

@@ -0,0 +1,3 @@
+export interface GenerateAuthenticatorAuthenticationOptionsRequestParams {
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Authenticator/GenerateAuthenticatorRegistrationOptionsRequestParams.ts

@@ -0,0 +1,5 @@
+export interface GenerateAuthenticatorRegistrationOptionsRequestParams {
+  userUuid: string
+  username: string
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Authenticator/ListAuthenticatorsRequestParams.ts

@@ -0,0 +1,3 @@
+export interface ListAuthenticatorsRequestParams {
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Authenticator/VerifyAuthenticatorAuthenticationResponseRequestParams.ts

@@ -0,0 +1,5 @@
+export interface VerifyAuthenticatorAuthenticationResponseRequestParams {
+  userUuid: string
+  authenticationCredential: Record<string, unknown>
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Authenticator/VerifyAuthenticatorRegistrationResponseRequestParams.ts

@@ -0,0 +1,6 @@
+export interface VerifyAuthenticatorRegistrationResponseRequestParams {
+  userUuid: string
+  name: string
+  registrationCredential: Record<string, unknown>
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/index.ts

@@ -1,4 +1,10 @@
 export * from './ApiEndpointParam'
+export * from './Authenticator/DeleteAuthenticatorRequestParams'
+export * from './Authenticator/GenerateAuthenticatorAuthenticationOptionsRequestParams'
+export * from './Authenticator/GenerateAuthenticatorRegistrationOptionsRequestParams'
+export * from './Authenticator/ListAuthenticatorsRequestParams'
+export * from './Authenticator/VerifyAuthenticatorAuthenticationResponseRequestParams'
+export * from './Authenticator/VerifyAuthenticatorRegistrationResponseRequestParams'
 export * from './Subscription/AppleIAPConfirmRequestParams'
 export * from './Subscription/SubscriptionInviteAcceptRequestParams'
 export * from './Subscription/SubscriptionInviteCancelRequestParams'

packages/api/src/Domain/Response/Auth/SessionRefreshResponse.ts

@@ -0,0 +1,9 @@
+import { Either } from '@standardnotes/common'
+
+import { HttpErrorResponseBody } from '../../Http/HttpErrorResponseBody'
+import { HttpResponse } from '../../Http/HttpResponse'
+import { SessionRefreshResponseBody } from './SessionRefreshResponseBody'
+
+export interface SessionRefreshResponse extends HttpResponse {
+  data: Either<SessionRefreshResponseBody, HttpErrorResponseBody>
+}

packages/api/src/Domain/Response/Auth/SessionRefreshResponseBody.ts

@@ -0,0 +1,9 @@
+export type SessionRefreshResponseBody = {
+  session: {
+    access_token: string
+    refresh_token: string
+    access_expiration: number
+    refresh_expiration: number
+    readonly_access: boolean
+  }
+}

packages/api/src/Domain/Response/Authenticator/DeleteAuthenticatorResponse.ts

@@ -0,0 +1,10 @@
+import { Either } from '@standardnotes/common'
+
+import { HttpErrorResponseBody } from '../../Http/HttpErrorResponseBody'
+import { HttpResponse } from '../../Http/HttpResponse'
+
+import { DeleteAuthenticatorResponseBody } from './DeleteAuthenticatorResponseBody'
+
+export interface DeleteAuthenticatorResponse extends HttpResponse {
+  data: Either<DeleteAuthenticatorResponseBody, HttpErrorResponseBody>
+}