chore(release): publish

- @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].6
 - @standardnotes/[email protected].9
 - @standardnotes/[email protected].9
 - @standardnotes/[email protected]

.github/workflows/snjs.pr.yml

@@ -17,6 +17,7 @@ on:
       - 'packages/sncrypto-web/**'
       - 'packages/snjs/**'
       - 'packages/utils/**'
+  workflow_dispatch:
 
 jobs:
   test:

.nvmrc

@@ -1 +1 @@
-16.15.1
+18.6.0

package.json

@@ -26,7 +26,6 @@
     "build:snjs": "yarn workspaces foreach -p --topological-dev --verbose -R --from @standardnotes/snjs run build",
     "build:services": "yarn workspaces foreach -pt --topological-dev --verbose -R --from @standardnotes/services run build",
     "build:api": "yarn workspaces foreach -pt --topological-dev --verbose -R --from @standardnotes/api run build",
-    "start:server:web": "lerna run start --scope=@standardnotes/web",
     "e2e": "lerna run start:test-server --scope=@standardnotes/snjs",
     "reset": "find . -type dir -name node_modules | xargs rm -rf && rm -rf yarn.lock && yarn install",
     "release:prod": "lerna version --conventional-commits --yes -m \"chore(release): publish\"",

packages/api/CHANGELOG.md

@@ -3,6 +3,68 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.26.25](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-07-11)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.24](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-07-11)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.23](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-07-07)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.22](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-07-06)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.21](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-07-05)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.20](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-07-04)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.19](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-07-03)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.18](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-06-30)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.17](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-06-29)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.16](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-06-27)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.15](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-06-26)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.14](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-06-25)
+
+### Bug Fixes
+
+* fixes issue where a renewed session would in some cases would not save to disk, causing a reauthentication prompt to occur ([bb804ff](https://github.com/standardnotes/app/commit/bb804fff45328eef3c66ec3a48dc000c21e37020))
+
+## [1.26.13](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-06-25)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.12](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-06-25)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.26.11](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-06-25)
+
+**Note:** Version bump only for package @standardnotes/api
+
 ## [1.26.10](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2023-05-22)
 
 **Note:** Version bump only for package @standardnotes/api

packages/api/jest.config.js

@@ -6,4 +6,5 @@ module.exports = {
   transform: {
     '^.+\\.tsx?$': ['ts-jest', { tsconfig: 'tsconfig.json' }],
   },
-};
+  coverageThreshold: {},
+}

packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/api",
-  "version": "1.26.10",
+  "version": "1.26.25",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },
@@ -36,9 +36,8 @@
     "typescript": "*"
   },
   "dependencies": {
-    "@standardnotes/common": "^1.46.6",
+    "@standardnotes/common": "^1.48.3",
     "@standardnotes/domain-core": "^1.12.0",
-    "@standardnotes/encryption": "workspace:*",
     "@standardnotes/models": "workspace:*",
     "@standardnotes/responses": "workspace:*",
     "@standardnotes/security": "^1.7.6",

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

@@ -1,14 +1,14 @@
 import { ErrorMessage } from '../../Error/ErrorMessage'
 import { ApiCallError } from '../../Error/ApiCallError'
 import { ApiVersion } from '../../Api/ApiVersion'
-import { ApiEndpointParam } from '../../Request/ApiEndpointParam'
+
 import { SubscriptionServerInterface } from '../../Server/Subscription/SubscriptionServerInterface'
 import { AppleIAPConfirmResponseBody } from './../../Response/Subscription/AppleIAPConfirmResponseBody'
 import { SubscriptionInviteAcceptResponseBody } from '../../Response/Subscription/SubscriptionInviteAcceptResponseBody'
 import { SubscriptionInviteCancelResponseBody } from '../../Response/Subscription/SubscriptionInviteCancelResponseBody'
 import { SubscriptionInviteListResponseBody } from '../../Response/Subscription/SubscriptionInviteListResponseBody'
 import { SubscriptionInviteResponseBody } from '../../Response/Subscription/SubscriptionInviteResponseBody'
-import { HttpResponse } from '@standardnotes/responses'
+import { HttpResponse, ApiEndpointParam } from '@standardnotes/responses'
 
 import { SubscriptionApiServiceInterface } from './SubscriptionApiServiceInterface'
 import { SubscriptionApiOperations } from './SubscriptionApiOperations'

packages/api/src/Domain/Client/User/UserApiOperations.ts

@@ -2,4 +2,5 @@ export enum UserApiOperations {
   Registering,
   SubmittingRequest,
   DeletingAccount,
+  UpdatingUser,
 }

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

@@ -5,8 +5,7 @@ import { ErrorMessage } from '../../Error/ErrorMessage'
 import { ApiCallError } from '../../Error/ApiCallError'
 import { UserServerInterface } from '../../Server/User/UserServerInterface'
 import { ApiVersion } from '../../Api/ApiVersion'
-import { ApiEndpointParam } from '../../Request/ApiEndpointParam'
-import { HttpResponse } from '@standardnotes/responses'
+import { HttpResponse, ApiEndpointParam } from '@standardnotes/responses'
 
 import { UserDeletionResponseBody } from '../../Response/User/UserDeletionResponseBody'
 import { UserRegistrationResponseBody } from '../../Response/User/UserRegistrationResponseBody'
@@ -15,6 +14,7 @@ import { UserRequestServerInterface } from '../../Server/UserRequest/UserRequest
 
 import { UserApiOperations } from './UserApiOperations'
 import { UserApiServiceInterface } from './UserApiServiceInterface'
+import { UserUpdateResponse } from '../../Response/User/UserUpdateResponse'
 
 export class UserApiService implements UserApiServiceInterface {
   private operationsInProgress: Map<UserApiOperations, boolean>
@@ -35,7 +35,7 @@ export class UserApiService implements UserApiServiceInterface {
 
       return response
     } catch (error) {
-      throw new ApiCallError(ErrorMessage.GenericRegistrationFail)
+      throw new ApiCallError(ErrorMessage.GenericFail)
     }
   }
 
@@ -84,6 +84,23 @@ export class UserApiService implements UserApiServiceInterface {
     }
   }
 
+  async updateUser(updateDTO: { userUuid: string }): Promise<HttpResponse<UserUpdateResponse>> {
+    this.lockOperation(UserApiOperations.UpdatingUser)
+
+    try {
+      const response = await this.userServer.update({
+        [ApiEndpointParam.ApiVersion]: ApiVersion.v0,
+        user_uuid: updateDTO.userUuid,
+      })
+
+      this.unlockOperation(UserApiOperations.UpdatingUser)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    }
+  }
+
   private lockOperation(operation: UserApiOperations): void {
     if (this.operationsInProgress.get(operation)) {
       throw new ApiCallError(ErrorMessage.GenericInProgress)

packages/api/src/Domain/Client/User/UserApiServiceInterface.ts

@@ -5,6 +5,7 @@ import { HttpResponse } from '@standardnotes/responses'
 import { UserDeletionResponseBody } from '../../Response/User/UserDeletionResponseBody'
 import { UserRegistrationResponseBody } from '../../Response/User/UserRegistrationResponseBody'
 import { UserRequestResponseBody } from '../../Response/UserRequest/UserRequestResponseBody'
+import { UserUpdateResponse } from '../../Response/User/UserUpdateResponse'
 
 export interface UserApiServiceInterface {
   register(registerDTO: {
@@ -13,9 +14,12 @@ export interface UserApiServiceInterface {
     keyParams: RootKeyParamsInterface
     ephemeral: boolean
   }): Promise<HttpResponse<UserRegistrationResponseBody>>
+  updateUser(updateDTO: { userUuid: string }): Promise<HttpResponse<UserUpdateResponse>>
+
   submitUserRequest(dto: {
     userUuid: string
     requestType: UserRequestType
   }): Promise<HttpResponse<UserRequestResponseBody>>
+
   deleteAccount(userUuid: string): Promise<HttpResponse<UserDeletionResponseBody>>
 }

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

@@ -0,0 +1,144 @@
+import { Environment } from '@standardnotes/models'
+import { HttpVerb } from '@standardnotes/responses'
+import { FetchRequestHandler } from './FetchRequestHandler'
+import { HttpErrorResponseBody, HttpRequest } from '@standardnotes/responses'
+
+import { ErrorMessage } from '../Error'
+
+describe('FetchRequestHandler', () => {
+  const snjsVersion = 'snjsVersion'
+  const appVersion = 'appVersion'
+  const environment = Environment.Web
+  const requestHandler = new FetchRequestHandler(snjsVersion, appVersion, environment)
+
+  it('should create a request', () => {
+    const httpRequest: HttpRequest = {
+      url: 'http://localhost:3000/test',
+      verb: HttpVerb.Get,
+      external: false,
+      authentication: 'authentication',
+      customHeaders: [],
+      params: {
+        key: 'value',
+      },
+    }
+
+    const request = requestHandler['createRequest'](httpRequest)
+
+    expect(request).toBeInstanceOf(Request)
+    expect(request.url).toBe(httpRequest.url)
+    expect(request.method).toBe(httpRequest.verb)
+    expect(request.headers.get('X-SNJS-Version')).toBe(snjsVersion)
+    expect(request.headers.get('X-Application-Version')).toBe(`${Environment[environment]}-${appVersion}`)
+    expect(request.headers.get('Content-Type')).toBe('application/json')
+  })
+
+  it('should get url for url and params', () => {
+    const urlWithoutExistingParams = requestHandler['urlForUrlAndParams']('url', { key: 'value' })
+    expect(urlWithoutExistingParams).toBe('url?key=value')
+
+    const urlWithExistingParams = requestHandler['urlForUrlAndParams']('url?key=value', { key2: 'value2' })
+    expect(urlWithExistingParams).toBe('url?key=value&key2=value2')
+  })
+
+  it('should create request body if not GET', () => {
+    const body = requestHandler['createRequestBody']({
+      url: 'url',
+      verb: HttpVerb.Post,
+      external: false,
+      authentication: 'authentication',
+      customHeaders: [],
+      params: {
+        key: 'value',
+      },
+    })
+
+    expect(body).toBe('{"key":"value"}')
+  })
+
+  it('should not create request body if GET', () => {
+    const body = requestHandler['createRequestBody']({
+      url: 'url',
+      verb: HttpVerb.Get,
+      external: false,
+      authentication: 'authentication',
+      customHeaders: [],
+      params: {
+        key: 'value',
+      },
+    })
+
+    expect(body).toBeUndefined()
+  })
+
+  it('should handle json response', async () => {
+    const fetchResponse = new Response('{"key":"value"}', {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    })
+
+    const response = await requestHandler['handleFetchResponse'](fetchResponse)
+
+    expect(response).toEqual({
+      status: 200,
+      headers: new Map<string, string | null>([['content-type', 'application/json']]),
+      data: {
+        key: 'value',
+      },
+      key: 'value',
+    })
+  })
+
+  it('should handle non-json response', async () => {
+    const fetchResponse = new Response('body', {
+      status: 200,
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    })
+
+    const response = await requestHandler['handleFetchResponse'](fetchResponse)
+
+    expect(response.status).toBe(200)
+    expect(response.headers).toEqual(new Map<string, string | null>([['content-type', 'text/plain']]))
+    expect(response.data).toBeInstanceOf(ArrayBuffer)
+  })
+
+  it('should have ratelimit error when forbidden', async () => {
+    const fetchResponse = new Response('body', {
+      status: 403,
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    })
+
+    const response = await requestHandler['handleFetchResponse'](fetchResponse)
+
+    expect(response.status).toBe(403)
+    expect(response.headers).toEqual(new Map<string, string | null>([['content-type', 'text/plain']]))
+    expect((response.data as HttpErrorResponseBody).error).toEqual({
+      message: ErrorMessage.RateLimited,
+    })
+  })
+
+  describe('should return ErrorResponse when status is not >=200 and <500', () => {
+    it('should add unknown error message when response has no data', async () => {
+      const fetchResponse = new Response('', {
+        status: 599,
+        headers: {
+          'Content-Type': 'text/plain',
+        },
+      })
+
+      const response = await requestHandler['handleFetchResponse'](fetchResponse)
+
+      expect(response.status).toBe(599)
+      expect(response.headers).toEqual(new Map<string, string | null>([['content-type', 'text/plain']]))
+      expect((response.data as HttpErrorResponseBody).error).toEqual({
+        message: 'Unknown error',
+      })
+    })
+  })
+})

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

@@ -0,0 +1,178 @@
+import {
+  HttpErrorResponse,
+  HttpRequest,
+  HttpRequestParams,
+  HttpResponse,
+  HttpStatusCode,
+  HttpVerb,
+  isErrorResponse,
+} from '@standardnotes/responses'
+import { RequestHandlerInterface } from './RequestHandlerInterface'
+import { Environment } from '@standardnotes/models'
+import { isString } from 'lodash'
+import { ErrorMessage } from '../Error'
+
+export class FetchRequestHandler implements RequestHandlerInterface {
+  constructor(
+    protected readonly snjsVersion: string,
+    protected readonly appVersion: string,
+    protected readonly environment: Environment,
+  ) {}
+
+  async handleRequest<T>(httpRequest: HttpRequest): Promise<HttpResponse<T>> {
+    const request = this.createRequest(httpRequest)
+
+    const response = await this.runRequest<T>(request, this.createRequestBody(httpRequest))
+
+    return response
+  }
+
+  private createRequest(httpRequest: HttpRequest): Request {
+    if (httpRequest.params && httpRequest.verb === HttpVerb.Get && Object.keys(httpRequest.params).length > 0) {
+      httpRequest.url = this.urlForUrlAndParams(httpRequest.url, httpRequest.params)
+    }
+
+    const headers: Record<string, string> = {}
+
+    if (!httpRequest.external) {
+      headers['X-SNJS-Version'] = this.snjsVersion
+
+      const appVersionHeaderValue = `${Environment[this.environment]}-${this.appVersion}`
+      headers['X-Application-Version'] = appVersionHeaderValue
+
+      if (httpRequest.authentication) {
+        headers['Authorization'] = 'Bearer ' + httpRequest.authentication
+      }
+    }
+
+    let contentTypeIsSet = false
+    if (httpRequest.customHeaders && httpRequest.customHeaders.length > 0) {
+      httpRequest.customHeaders.forEach(({ key, value }) => {
+        headers[key] = value
+        if (key === 'Content-Type') {
+          contentTypeIsSet = true
+        }
+      })
+    }
+    if (!contentTypeIsSet && !httpRequest.external) {
+      headers['Content-Type'] = 'application/json'
+    }
+
+    return new Request(httpRequest.url, {
+      method: httpRequest.verb,
+      headers,
+    })
+  }
+
+  private async runRequest<T>(request: Request, body?: string | Uint8Array | undefined): Promise<HttpResponse<T>> {
+    const fetchResponse = await fetch(request, {
+      body,
+    })
+
+    const response = await this.handleFetchResponse<T>(fetchResponse)
+
+    return response
+  }
+
+  private async handleFetchResponse<T>(fetchResponse: Response): Promise<HttpResponse<T>> {
+    const httpStatus = fetchResponse.status
+    const response: HttpResponse<T> = {
+      status: httpStatus,
+      headers: new Map<string, string | null>(),
+      data: {} as T,
+    }
+    fetchResponse.headers.forEach((value, key) => {
+      ;(<Map<string, string | null>>response.headers).set(key, value)
+    })
+
+    try {
+      if (httpStatus !== HttpStatusCode.NoContent) {
+        let body
+
+        const contentTypeHeader = response.headers?.get('content-type') || response.headers?.get('Content-Type')
+
+        if (contentTypeHeader?.includes('application/json')) {
+          body = JSON.parse(await fetchResponse.text())
+        } else {
+          body = await fetchResponse.arrayBuffer()
+        }
+        /**
+         * v0 APIs do not have a `data` top-level object. In such cases, mimic
+         * the newer response body style by putting all the top-level
+         * properties inside a `data` object.
+         */
+        if (!body.data) {
+          response.data = body
+        }
+        if (!isString(body)) {
+          Object.assign(response, body)
+        }
+      }
+    } catch (error) {
+      console.error(error)
+    }
+
+    if (httpStatus >= HttpStatusCode.Success && httpStatus < HttpStatusCode.InternalServerError) {
+      if (httpStatus === HttpStatusCode.Forbidden && isErrorResponse(response)) {
+        if (!response.data.error) {
+          response.data.error = {
+            message: ErrorMessage.RateLimited,
+          }
+        } else {
+          response.data.error.message = ErrorMessage.RateLimited
+        }
+      }
+      return response
+    } else {
+      const errorResponse = response as HttpErrorResponse
+      if (!errorResponse.data) {
+        errorResponse.data = {
+          error: {
+            message: 'Unknown error',
+          },
+        }
+      }
+
+      if (isString(errorResponse.data)) {
+        errorResponse.data = {
+          error: {
+            message: errorResponse.data,
+          },
+        }
+      }
+
+      if (!errorResponse.data.error) {
+        errorResponse.data.error = {
+          message: 'Unknown error',
+        }
+      }
+
+      return errorResponse
+    }
+  }
+
+  private urlForUrlAndParams(url: string, params: HttpRequestParams) {
+    const keyValueString = Object.keys(params as Record<string, unknown>)
+      .map((key) => {
+        return key + '=' + encodeURIComponent((params as Record<string, unknown>)[key] as string)
+      })
+      .join('&')
+
+    if (url.includes('?')) {
+      return url + '&' + keyValueString
+    } else {
+      return url + '?' + keyValueString
+    }
+  }
+
+  private createRequestBody(httpRequest: HttpRequest): string | Uint8Array | undefined {
+    if (
+      httpRequest.params !== undefined &&
+      [HttpVerb.Post, HttpVerb.Put, HttpVerb.Patch, HttpVerb.Delete].includes(httpRequest.verb)
+    ) {
+      return JSON.stringify(httpRequest.params)
+    }
+
+    return httpRequest.rawBytes
+  }
+}

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

@@ -1,4 +1,4 @@
-import { isString, joinPaths, sleep } from '@standardnotes/utils'
+import { joinPaths, sleep } from '@standardnotes/utils'
 import { Environment } from '@standardnotes/models'
 import { Session, SessionToken } from '@standardnotes/domain-core'
 import {
@@ -8,15 +8,14 @@ import {
   HttpRequest,
   HttpResponse,
   HttpResponseMeta,
-  HttpErrorResponse,
   isErrorResponse,
 } from '@standardnotes/responses'
 import { HttpServiceInterface } from './HttpServiceInterface'
-import { XMLHttpRequestState } from './XMLHttpRequestState'
-import { ErrorMessage } from '../Error/ErrorMessage'
 
 import { Paths } from '../Server/Auth/Paths'
 import { SessionRefreshResponseBody } from '../Response/Auth/SessionRefreshResponseBody'
+import { FetchRequestHandler } from './FetchRequestHandler'
+import { RequestHandlerInterface } from './RequestHandlerInterface'
 
 export class HttpService implements HttpServiceInterface {
   private session: Session | null
@@ -27,8 +26,11 @@ export class HttpService implements HttpServiceInterface {
   private updateMetaCallback!: (meta: HttpResponseMeta) => void
   private refreshSessionCallback!: (session: Session) => void
 
+  private requestHandler: RequestHandlerInterface
+
   constructor(private environment: Environment, private appVersion: string, private snjsVersion: string) {
     this.session = null
+    this.requestHandler = new FetchRequestHandler(this.snjsVersion, this.appVersion, this.environment)
   }
 
   setCallbacks(
@@ -53,7 +55,15 @@ export class HttpService implements HttpServiceInterface {
     this.host = host
   }
 
+  getHost(): string {
+    return this.host
+  }
+
   async get<T>(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse<T>> {
+    if (!this.host) {
+      throw new Error('Attempting to make network request before host is set')
+    }
+
     return this.runHttp({
       url: joinPaths(this.host, path),
       params,
@@ -62,7 +72,20 @@ export class HttpService implements HttpServiceInterface {
     })
   }
 
+  async getExternal<T>(url: string, params?: HttpRequestParams): Promise<HttpResponse<T>> {
+    return this.runHttp({
+      url,
+      params,
+      verb: HttpVerb.Get,
+      external: true,
+    })
+  }
+
   async post<T>(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse<T>> {
+    if (!this.host) {
+      throw new Error('Attempting to make network request before host is set')
+    }
+
     return this.runHttp({
       url: joinPaths(this.host, path),
       params,
@@ -99,25 +122,24 @@ export class HttpService implements HttpServiceInterface {
   }
 
   async runHttp<T>(httpRequest: HttpRequest): Promise<HttpResponse<T>> {
-    if (this.inProgressRefreshSessionPromise) {
+    if (this.__latencySimulatorMs) {
+      await sleep(this.__latencySimulatorMs, true)
+    }
+
+    const isRefreshRequest = httpRequest.url === joinPaths(this.host, Paths.v1.refreshSession)
+    if (this.inProgressRefreshSessionPromise && !isRefreshRequest) {
       await this.inProgressRefreshSessionPromise
 
       httpRequest.authentication = this.session?.accessToken.value
     }
 
-    const request = this.createXmlRequest(httpRequest)
+    const response = await this.requestHandler.handleRequest<T>(httpRequest)
 
-    if (this.__latencySimulatorMs) {
-      await sleep(this.__latencySimulatorMs, true)
-    }
-
-    const response = await this.runRequest<T>(request, this.createRequestBody(httpRequest))
-
-    if (response.meta) {
+    if (response.meta && !httpRequest.external) {
       this.updateMetaCallback?.(response.meta)
     }
 
-    if (response.status === HttpStatusCode.ExpiredAccessToken) {
+    if (response.status === HttpStatusCode.ExpiredAccessToken && !isRefreshRequest && !httpRequest.external) {
       if (this.inProgressRefreshSessionPromise) {
         await this.inProgressRefreshSessionPromise
       } else {
@@ -187,159 +209,4 @@ export class HttpService implements HttpServiceInterface {
 
     return true
   }
-
-  private createRequestBody(httpRequest: HttpRequest): string | Uint8Array | undefined {
-    if (
-      httpRequest.params !== undefined &&
-      [HttpVerb.Post, HttpVerb.Put, HttpVerb.Patch, HttpVerb.Delete].includes(httpRequest.verb)
-    ) {
-      return JSON.stringify(httpRequest.params)
-    }
-
-    return httpRequest.rawBytes
-  }
-
-  private createXmlRequest(httpRequest: HttpRequest) {
-    const request = new XMLHttpRequest()
-    if (httpRequest.params && httpRequest.verb === HttpVerb.Get && Object.keys(httpRequest.params).length > 0) {
-      httpRequest.url = this.urlForUrlAndParams(httpRequest.url, httpRequest.params)
-    }
-    request.open(httpRequest.verb, httpRequest.url, true)
-    request.responseType = httpRequest.responseType ?? ''
-
-    if (!httpRequest.external) {
-      request.setRequestHeader('X-SNJS-Version', this.snjsVersion)
-
-      const appVersionHeaderValue = `${Environment[this.environment]}-${this.appVersion}`
-      request.setRequestHeader('X-Application-Version', appVersionHeaderValue)
-
-      if (httpRequest.authentication) {
-        request.setRequestHeader('Authorization', 'Bearer ' + httpRequest.authentication)
-      }
-    }
-
-    let contenTypeIsSet = false
-    if (httpRequest.customHeaders && httpRequest.customHeaders.length > 0) {
-      httpRequest.customHeaders.forEach(({ key, value }) => {
-        request.setRequestHeader(key, value)
-        if (key === 'Content-Type') {
-          contenTypeIsSet = true
-        }
-      })
-    }
-    if (!contenTypeIsSet && !httpRequest.external) {
-      request.setRequestHeader('Content-Type', 'application/json')
-    }
-
-    return request
-  }
-
-  private async runRequest<T>(request: XMLHttpRequest, body?: string | Uint8Array): Promise<HttpResponse<T>> {
-    return new Promise((resolve) => {
-      request.onreadystatechange = () => {
-        this.stateChangeHandlerForRequest(request, resolve)
-      }
-      request.send(body)
-    })
-  }
-
-  private stateChangeHandlerForRequest<T>(request: XMLHttpRequest, resolve: (response: HttpResponse<T>) => void) {
-    if (request.readyState !== XMLHttpRequestState.Completed) {
-      return
-    }
-    const httpStatus = request.status
-    const response: HttpResponse<T> = {
-      status: httpStatus,
-      headers: new Map<string, string | null>(),
-      data: {} as T,
-    }
-
-    const responseHeaderLines = request
-      .getAllResponseHeaders()
-      ?.trim()
-      .split(/[\r\n]+/)
-    responseHeaderLines?.forEach((responseHeaderLine) => {
-      const parts = responseHeaderLine.split(': ')
-      const name = parts.shift() as string
-      const value = parts.join(': ')
-
-      ;(<Map<string, string | null>>response.headers).set(name, value)
-    })
-
-    try {
-      if (httpStatus !== HttpStatusCode.NoContent) {
-        let body
-
-        const contentTypeHeader = response.headers?.get('content-type') || response.headers?.get('Content-Type')
-
-        if (contentTypeHeader?.includes('application/json')) {
-          body = JSON.parse(request.responseText)
-        } else {
-          body = request.response
-        }
-        /**
-         * v0 APIs do not have a `data` top-level object. In such cases, mimic
-         * the newer response body style by putting all the top-level
-         * properties inside a `data` object.
-         */
-        if (!body.data) {
-          response.data = body
-        }
-        if (!isString(body)) {
-          Object.assign(response, body)
-        }
-      }
-    } catch (error) {
-      console.error(error)
-    }
-    if (httpStatus >= HttpStatusCode.Success && httpStatus < HttpStatusCode.InternalServerError) {
-      if (
-        httpStatus === HttpStatusCode.Forbidden &&
-        response.data &&
-        (response as HttpErrorResponse).data.error !== undefined
-      ) {
-        ;(response as HttpErrorResponse).data.error.message = ErrorMessage.RateLimited
-      }
-      resolve(response)
-    } else {
-      const errorResponse = response as HttpErrorResponse
-      if (!errorResponse.data) {
-        errorResponse.data = {
-          error: {
-            message: 'Unknown error',
-          },
-        }
-      }
-
-      if (isString(errorResponse.data)) {
-        errorResponse.data = {
-          error: {
-            message: errorResponse.data,
-          },
-        }
-      }
-
-      if (!errorResponse.data.error) {
-        errorResponse.data.error = {
-          message: 'Unknown error',
-        }
-      }
-
-      resolve(errorResponse)
-    }
-  }
-
-  private urlForUrlAndParams(url: string, params: HttpRequestParams) {
-    const keyValueString = Object.keys(params as Record<string, unknown>)
-      .map((key) => {
-        return key + '=' + encodeURIComponent((params as Record<string, unknown>)[key] as string)
-      })
-      .join('&')
-
-    if (url.includes('?')) {
-      return url + '&' + keyValueString
-    } else {
-      return url + '?' + keyValueString
-    }
-  }
 }

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

@@ -3,8 +3,10 @@ import { HttpRequest, HttpRequestParams, HttpResponse, HttpResponseMeta } from '
 
 export interface HttpServiceInterface {
   setHost(host: string): void
+  getHost(): string
   setSession(session: Session): void
   get<T>(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse<T>>
+  getExternal<T>(url: string, params?: HttpRequestParams): Promise<HttpResponse<T>>
   post<T>(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse<T>>
   put<T>(path: string, params?: HttpRequestParams, authentication?: string): Promise<HttpResponse<T>>
   patch<T>(path: string, params: HttpRequestParams, authentication?: string): Promise<HttpResponse<T>>

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

@@ -0,0 +1,5 @@
+import { HttpRequest, HttpResponse } from '@standardnotes/responses'
+
+export interface RequestHandlerInterface {
+  handleRequest<T>(httpRequest: HttpRequest): Promise<HttpResponse<T>>
+}

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

@@ -1,7 +0,0 @@
-export enum ApiEndpointParam {
-  LastSyncToken = 'sync_token',
-  PaginationToken = 'cursor_token',
-  SyncDlLimit = 'limit',
-  SyncPayloads = 'items',
-  ApiVersion = 'api',
-}

packages/api/src/Domain/Request/AsymmetricMessage/CreateAsymmetricMessageParams.ts

@@ -0,0 +1,5 @@
+export type CreateAsymmetricMessageParams = {
+  recipientUuid: string
+  encryptedMessage: string
+  replaceabilityIdentifier?: string
+}

packages/api/src/Domain/Request/AsymmetricMessage/DeleteAsymmetricMessageRequestParams.ts

@@ -0,0 +1,3 @@
+export type DeleteAsymmetricMessageRequestParams = {
+  messageUuid: string
+}

packages/api/src/Domain/Request/AsymmetricMessage/GetOutboundAsymmetricMessagesRequestParams.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type GetOutboundAsymmetricMessagesRequestParams = {}

packages/api/src/Domain/Request/AsymmetricMessage/GetUserAsymmetricMessagesRequestParams.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type GetUserAsymmetricMessagesRequestParams = {}

packages/api/src/Domain/Request/AsymmetricMessage/UpdateAsymmetricMessageParams.ts

@@ -0,0 +1,4 @@
+export type UpdateAsymmetricMessageParams = {
+  messageUuid: string
+  encryptedMessage: string
+}

packages/api/src/Domain/Request/SharedVault/CreateSharedVaultValetTokenParams.ts

@@ -0,0 +1,12 @@
+import { ValetTokenOperation } from '@standardnotes/responses'
+import { SharedVaultMoveType } from './SharedVaultMoveType'
+
+export type CreateSharedVaultValetTokenParams = {
+  sharedVaultUuid: string
+  fileUuid?: string
+  remoteIdentifier: string
+  operation: ValetTokenOperation
+  unencryptedFileSize?: number
+  moveOperationType?: SharedVaultMoveType
+  sharedVaultToSharedVaultMoveTargetUuid?: string
+}

packages/api/src/Domain/Request/SharedVault/SharedVaultMoveType.ts

@@ -0,0 +1 @@
+export type SharedVaultMoveType = 'shared-vault-to-user' | 'user-to-shared-vault' | 'shared-vault-to-shared-vault'

packages/api/src/Domain/Request/SharedVaultInvites/AcceptInviteRequestParams.ts

@@ -0,0 +1,4 @@
+export type AcceptInviteRequestParams = {
+  sharedVaultUuid: string
+  inviteUuid: string
+}

packages/api/src/Domain/Request/SharedVaultInvites/CreateSharedVaultInviteParams.ts

@@ -0,0 +1,8 @@
+import { SharedVaultPermission } from '@standardnotes/responses'
+
+export type CreateSharedVaultInviteParams = {
+  sharedVaultUuid: string
+  recipientUuid: string
+  encryptedMessage: string
+  permissions: SharedVaultPermission
+}

packages/api/src/Domain/Request/SharedVaultInvites/DeclineInviteRequestParams.ts

@@ -0,0 +1,4 @@
+export type DeclineInviteRequestParams = {
+  sharedVaultUuid: string
+  inviteUuid: string
+}

packages/api/src/Domain/Request/SharedVaultInvites/DeleteAllSharedVaultInvitesRequestParams.ts

@@ -0,0 +1,3 @@
+export type DeleteAllSharedVaultInvitesRequestParams = {
+  sharedVaultUuid: string
+}

packages/api/src/Domain/Request/SharedVaultInvites/DeleteInviteRequestParams.ts

@@ -0,0 +1,4 @@
+export type DeleteInviteRequestParams = {
+  sharedVaultUuid: string
+  inviteUuid: string
+}

packages/api/src/Domain/Request/SharedVaultInvites/GetOutboundUserInvitesRequestParams.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type GetOutboundUserInvitesRequestParams = {}

packages/api/src/Domain/Request/SharedVaultInvites/GetSharedVaultInvitesRequestParams.ts

@@ -0,0 +1,3 @@
+export type GetSharedVaultInvitesRequestParams = {
+  sharedVaultUuid: string
+}

packages/api/src/Domain/Request/SharedVaultInvites/GetUserInvitesRequestParams.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type GetUserInvitesRequestParams = {}

packages/api/src/Domain/Request/SharedVaultInvites/UpdateSharedVaultInviteParams.ts

@@ -0,0 +1,8 @@
+import { SharedVaultPermission } from '@standardnotes/responses'
+
+export type UpdateSharedVaultInviteParams = {
+  sharedVaultUuid: string
+  inviteUuid: string
+  encryptedMessage: string
+  permissions?: SharedVaultPermission
+}

packages/api/src/Domain/Request/SharedVaultUser/DeleteSharedVaultUserRequestParams.ts

@@ -0,0 +1,4 @@
+export type DeleteSharedVaultUserRequestParams = {
+  sharedVaultUuid: string
+  userUuid: string
+}

packages/api/src/Domain/Request/SharedVaultUser/GetSharedVaultUsersRequestParams.ts

@@ -0,0 +1,3 @@
+export type GetSharedVaultUsersRequestParams = {
+  sharedVaultUuid: string
+}

packages/api/src/Domain/Request/Subscription/SubscriptionInviteCancelRequestParams.ts

@@ -1,8 +1,7 @@
-import { ApiEndpointParam } from '../ApiEndpointParam'
-import { ApiVersion } from '../../Api/ApiVersion'
+import { ApiEndpointParam } from '@standardnotes/responses'
 
 export type SubscriptionInviteCancelRequestParams = {
-  [ApiEndpointParam.ApiVersion]: ApiVersion.v0
+  [ApiEndpointParam.ApiVersion]: string
   inviteUuid: string
   [additionalParam: string]: unknown
 }

packages/api/src/Domain/Request/Subscription/SubscriptionInviteDeclineRequestParams.ts

@@ -1,8 +1,7 @@
-import { ApiEndpointParam } from '../ApiEndpointParam'
-import { ApiVersion } from '../../Api/ApiVersion'
+import { ApiEndpointParam } from '@standardnotes/responses'
 
 export type SubscriptionInviteDeclineRequestParams = {
-  [ApiEndpointParam.ApiVersion]: ApiVersion.v0
+  [ApiEndpointParam.ApiVersion]: string
   inviteUuid: string
   [additionalParam: string]: unknown
 }

packages/api/src/Domain/Request/Subscription/SubscriptionInviteListRequestParams.ts

@@ -1,7 +1,6 @@
-import { ApiEndpointParam } from '../ApiEndpointParam'
-import { ApiVersion } from '../../Api/ApiVersion'
+import { ApiEndpointParam } from '@standardnotes/responses'
 
 export type SubscriptionInviteListRequestParams = {
-  [ApiEndpointParam.ApiVersion]: ApiVersion.v0
+  [ApiEndpointParam.ApiVersion]: string
   [additionalParam: string]: unknown
 }

packages/api/src/Domain/Request/Subscription/SubscriptionInviteRequestParams.ts

@@ -1,8 +1,7 @@
-import { ApiEndpointParam } from '../ApiEndpointParam'
-import { ApiVersion } from '../../Api/ApiVersion'
+import { ApiEndpointParam } from '@standardnotes/responses'
 
 export type SubscriptionInviteRequestParams = {
-  [ApiEndpointParam.ApiVersion]: ApiVersion.v0
+  [ApiEndpointParam.ApiVersion]: string
   identifier: string
   [additionalParam: string]: unknown
 }

packages/api/src/Domain/Request/User/UserRegistrationRequestParams.ts

@@ -1,13 +1,10 @@
 import { AnyKeyParamsContent } from '@standardnotes/common'
-import { ApiEndpointParam } from '../ApiEndpointParam'
-import { ApiVersion } from '../../Api/ApiVersion'
+import { ApiEndpointParam } from '@standardnotes/responses'
 
 export type UserRegistrationRequestParams = AnyKeyParamsContent & {
-  [ApiEndpointParam.ApiVersion]: ApiVersion.v0
+  [ApiEndpointParam.ApiVersion]: string
+  [additionalParam: string]: unknown
   password: string
   email: string
   ephemeral: boolean
-  [additionalParam: string]: unknown
-  pkcPublicKey?: string
-  pkcEncryptedPrivateKey?: string
 }

packages/api/src/Domain/Request/User/UserUpdateRequestParams.ts

@@ -0,0 +1,6 @@
+import { ApiEndpointParam } from '@standardnotes/responses'
+
+export type UserUpdateRequestParams = {
+  [ApiEndpointParam.ApiVersion]: string
+  user_uuid: string
+}

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

@@ -1,4 +1,3 @@
-export * from './ApiEndpointParam'
 export * from './Authenticator/DeleteAuthenticatorRequestParams'
 export * from './Authenticator/GenerateAuthenticatorAuthenticationOptionsRequestParams'
 export * from './Authenticator/ListAuthenticatorsRequestParams'
@@ -14,6 +13,9 @@ export * from './Subscription/SubscriptionInviteCancelRequestParams'
 export * from './Subscription/SubscriptionInviteDeclineRequestParams'
 export * from './Subscription/SubscriptionInviteListRequestParams'
 export * from './Subscription/SubscriptionInviteRequestParams'
+export * from './User/UserDeletionRequestParams'
 export * from './User/UserRegistrationRequestParams'
+export * from './User/UserUpdateRequestParams'
 export * from './UserRequest/UserRequestRequestParams'
 export * from './WebSocket/WebSocketConnectionTokenRequestParams'
+export * from './SharedVault/SharedVaultMoveType'

packages/api/src/Domain/Response/AsymmetricMessage/CreateAsymmetricMessageResponse.ts

@@ -0,0 +1,5 @@
+import { AsymmetricMessageServerHash } from '@standardnotes/responses'
+
+export type CreateAsymmetricMessageResponse = {
+  message: AsymmetricMessageServerHash
+}

packages/api/src/Domain/Response/AsymmetricMessage/DeleteAsymmetricMessageResponse.ts

@@ -0,0 +1,3 @@
+export type DeleteAsymmetricMessageResponse = {
+  success: boolean
+}

packages/api/src/Domain/Response/AsymmetricMessage/GetOutboundAsymmetricMessagesResponse.ts

@@ -0,0 +1,5 @@
+import { AsymmetricMessageServerHash } from '@standardnotes/responses'
+
+export type GetOutboundAsymmetricMessagesResponse = {
+  messages: AsymmetricMessageServerHash[]
+}

packages/api/src/Domain/Response/AsymmetricMessage/GetUserAsymmetricMessagesResponse.ts

@@ -0,0 +1,5 @@
+import { AsymmetricMessageServerHash } from '@standardnotes/responses'
+
+export type GetUserAsymmetricMessagesResponse = {
+  messages: AsymmetricMessageServerHash[]
+}