chore(release): publish

- @standardnotes/[email protected].0
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].3
 - @standardnotes/[email protected]
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].6
 - @standardnotes/[email protected].0
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].0
 - @standardnotes/[email protected].3
 - @standardnotes/[email protected]
 - @standardnotes/[email protected].5

.eslintignore

@@ -1,2 +1,19 @@
 node_modules
-scripts
+scripts
+actions
+.yarn
+.vscode
+.sass-cache
+.husky
+.github
+.git
+**/dist
+**/coverage
+**/node_modules
+packages/components
+packages/docs
+packages/mobile/android
+packages/mobile/ios
+packages/mobile/html
+packages/snjs/mocha
+*.d.ts

.eslintrc.json

@@ -1,4 +1,4 @@
 {
   "extends": ["./node_modules/@standardnotes/config/src/.eslintrc"],
-  "ignorePatterns": [".eslintrc.js", "*.webpack.*.js", "webpack-defaults.js", "jest.config.js", "__mocks__"]
+  "ignorePatterns": [".eslintrc.js", "*.webpack.*.js", "webpack-defaults.js", "jest.config.js", "__mocks__", "**/**/coverage"]
 }

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

@@ -48,16 +48,6 @@ jobs:
         uses: martinbeentjes/npm-get-version-action@main
         with:
           path: packages/mobile
-      - name: Release
-        uses: softprops/action-gh-release@v1
-        with:
-          token: ${{ secrets.CI_PAT_TOKEN }}
-          tag_name: "@standardnotes/mobile@${{ steps.package-version.outputs.current-version}}"
-          prerelease: true
-          draft: true
-          name: "Mobile Dev ${{ steps.package-version.outputs.current-version }}"
-          files: |
-            packages/mobile/android/app/build/outputs/apk/dev/release/app-dev-release.apk
   ios:
     defaults:
       run:

packages/api/.eslintignore

@@ -1,2 +1,3 @@
 node_modules
 dist
+coverage

packages/api/CHANGELOG.md

@@ -3,6 +3,91 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [1.13.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-10-11)
+
+### Features
+
+* **api:** add accepting invites to workspace ([15e2c82](https://github.com/standardnotes/app/commit/15e2c82e654ce3f983cd42b01f14d18435b3e939))
+* **api:** add listing workspaces ([8376381](https://github.com/standardnotes/app/commit/837638198112df24c30e53803a7ddf5f841975b0))
+
+## [1.12.1](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-10-10)
+
+**Note:** Version bump only for package @standardnotes/api
+
+# [1.12.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-10-10)
+
+### Bug Fixes
+
+* **api:** specs ([85d2415](https://github.com/standardnotes/app/commit/85d24156254015914c684f900c77c080caa52eb7))
+* **api:** workspace creation arguments ([a275a45](https://github.com/standardnotes/app/commit/a275a45753abc4a29a89de5fe784260165297bbe))
+* linter issues ([e2e7605](https://github.com/standardnotes/app/commit/e2e76054142e8d67cac69280e2a3efcb15cf67f1))
+
+### Features
+
+* **api:** add inviting to workspace ([158ca6a](https://github.com/standardnotes/app/commit/158ca6ac6a428e082c8f984791f80fcaadcb3e34))
+
+# [1.11.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-10-07)
+
+### Features
+
+* **api:** add workspaces api ([#1765](https://github.com/standardnotes/app/issues/1765)) ([01ba715](https://github.com/standardnotes/app/commit/01ba715eba987a7da1ee062fec0b3593a7a453ed))
+
+# [1.10.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-10-06)
+
+### Features
+
+* experimental 005 operator ([#1753](https://github.com/standardnotes/app/issues/1753)) ([cbbe913](https://github.com/standardnotes/app/commit/cbbe913cd6eb694dd27997927bd5c45e8a64cc09))
+
+## [1.9.2](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-10-05)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.9.1](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-10-05)
+
+**Note:** Version bump only for package @standardnotes/api
+
+# [1.9.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-10-03)
+
+### Features
+
+* **api:** add http status code for gone resource ([d54e696](https://github.com/standardnotes/app/commit/d54e6965c188e9f12371b32868e8de1c2f627f30))
+
+## [1.8.7](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-30)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.8.6](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-29)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.8.5](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-29)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.8.4](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-28)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.8.3](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-24)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.8.2](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-23)
+
+**Note:** Version bump only for package @standardnotes/api
+
+## [1.8.1](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-20)
+
+### Bug Fixes
+
+* move wrapped storage to unwrapped if not encrypted ([#1603](https://github.com/standardnotes/app/issues/1603)) ([c5e225d](https://github.com/standardnotes/app/commit/c5e225d335537257f44168b8ad05222afccb508a))
+
+# [1.8.0](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-20)
+
+### Features
+
+* **api:** add websocket api definitions ([4a773fa](https://github.com/standardnotes/app/commit/4a773fa53796e17ce5df325ed7d40ba2cb686476))
+
 ## [1.7.2](https://github.com/standardnotes/app/compare/@standardnotes/[email protected]...@standardnotes/[email protected]) (2022-09-15)
 
 **Note:** Version bump only for package @standardnotes/api

packages/api/jest.config.js

@@ -10,10 +10,10 @@ module.exports = {
   },
   coverageThreshold: {
     global: {
-      branches: 17,
-      functions: 43,
-      lines: 46,
-      statements: 46
+      branches: 22,
+      functions: 69,
+      lines: 67,
+      statements: 67
     }
   }
 };

packages/api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/api",
-  "version": "1.7.2",
+  "version": "1.13.0",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },
@@ -32,10 +32,11 @@
     "eslint": "^8.23.0",
     "eslint-plugin-prettier": "*",
     "jest": "^28.1.2",
-    "ts-jest": "^28.0.5"
+    "ts-jest": "^28.0.5",
+    "typescript": "*"
   },
   "dependencies": {
-    "@standardnotes/common": "^1.32.0",
+    "@standardnotes/common": "^1.36.1",
     "@standardnotes/encryption": "workspace:*",
     "@standardnotes/models": "workspace:*",
     "@standardnotes/responses": "workspace:*",

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

@@ -24,7 +24,12 @@ describe('UserApiService', () => {
   })
 
   it('should register a user', async () => {
-    const response = await createService().register('[email protected]', 'testpasswd', keyParams, false)
+    const response = await createService().register({
+      email: '[email protected]',
+      serverPassword: 'testpasswd',
+      keyParams,
+      ephemeral: false,
+    })
 
     expect(response).toEqual({
       data: {
@@ -52,7 +57,7 @@ describe('UserApiService', () => {
 
     let error = null
     try {
-      await service.register('[email protected]', 'testpasswd', keyParams, false)
+      await service.register({ email: '[email protected]', serverPassword: 'testpasswd', keyParams, ephemeral: false })
     } catch (caughtError) {
       error = caughtError
     }
@@ -67,7 +72,12 @@ describe('UserApiService', () => {
 
     let error = null
     try {
-      await createService().register('[email protected]', 'testpasswd', keyParams, false)
+      await createService().register({
+        email: '[email protected]',
+        serverPassword: 'testpasswd',
+        keyParams,
+        ephemeral: false,
+      })
     } catch (caughtError) {
       error = caughtError
     }

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

@@ -1,5 +1,4 @@
 import { RootKeyParamsInterface } from '@standardnotes/models'
-
 import { ErrorMessage } from '../../Error/ErrorMessage'
 import { ApiCallError } from '../../Error/ApiCallError'
 import { UserRegistrationResponse } from '../../Response/User/UserRegistrationResponse'
@@ -15,12 +14,12 @@ export class UserApiService implements UserApiServiceInterface {
     this.registering = false
   }
 
-  async register(
-    email: string,
-    serverPassword: string,
-    keyParams: RootKeyParamsInterface,
-    ephemeral: boolean,
-  ): Promise<UserRegistrationResponse> {
+  async register(registerDTO: {
+    email: string
+    serverPassword: string
+    keyParams: RootKeyParamsInterface
+    ephemeral: boolean
+  }): Promise<UserRegistrationResponse> {
     if (this.registering) {
       throw new ApiCallError(ErrorMessage.RegistrationInProgress)
     }
@@ -29,10 +28,10 @@ export class UserApiService implements UserApiServiceInterface {
     try {
       const response = await this.userServer.register({
         [ApiEndpointParam.ApiVersion]: ApiVersion.v0,
-        password: serverPassword,
-        email,
-        ephemeral,
-        ...keyParams.getPortableValue(),
+        password: registerDTO.serverPassword,
+        email: registerDTO.email,
+        ephemeral: registerDTO.ephemeral,
+        ...registerDTO.keyParams.getPortableValue(),
       })
 
       this.registering = false

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

@@ -2,10 +2,10 @@ import { RootKeyParamsInterface } from '@standardnotes/models'
 import { UserRegistrationResponse } from '../../Response/User/UserRegistrationResponse'
 
 export interface UserApiServiceInterface {
-  register(
-    email: string,
-    serverPassword: string,
-    keyParams: RootKeyParamsInterface,
-    ephemeral: boolean,
-  ): Promise<UserRegistrationResponse>
+  register(registerDTO: {
+    email: string
+    serverPassword: string
+    keyParams: RootKeyParamsInterface
+    ephemeral: boolean
+  }): Promise<UserRegistrationResponse>
 }

packages/api/src/Domain/Client/WebSocket/WebSocketApiOperations.ts

@@ -0,0 +1,3 @@
+export enum WebSocketApiOperations {
+  CreatingConnectionToken,
+}

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

@@ -0,0 +1,61 @@
+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/WebSocket/WebSocketApiService.ts

@@ -0,0 +1,33 @@
+import { ErrorMessage } from '../../Error/ErrorMessage'
+import { ApiCallError } from '../../Error/ApiCallError'
+
+import { WebSocketApiServiceInterface } from './WebSocketApiServiceInterface'
+import { WebSocketApiOperations } from './WebSocketApiOperations'
+import { WebSocketServerInterface } from '../../Server'
+import { WebSocketConnectionTokenResponse } from '../../Response'
+
+export class WebSocketApiService implements WebSocketApiServiceInterface {
+  private operationsInProgress: Map<WebSocketApiOperations, boolean>
+
+  constructor(private webSocketServer: WebSocketServerInterface) {
+    this.operationsInProgress = new Map()
+  }
+
+  async createConnectionToken(): Promise<WebSocketConnectionTokenResponse> {
+    if (this.operationsInProgress.get(WebSocketApiOperations.CreatingConnectionToken)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(WebSocketApiOperations.CreatingConnectionToken, true)
+
+    try {
+      const response = await this.webSocketServer.createConnectionToken({})
+
+      this.operationsInProgress.set(WebSocketApiOperations.CreatingConnectionToken, false)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    }
+  }
+}

packages/api/src/Domain/Client/WebSocket/WebSocketApiServiceInterface.ts

@@ -0,0 +1,5 @@
+import { WebSocketConnectionTokenResponse } from '../../Response'
+
+export interface WebSocketApiServiceInterface {
+  createConnectionToken(): Promise<WebSocketConnectionTokenResponse>
+}

packages/api/src/Domain/Client/Workspace/WorkspaceApiOperations.ts

@@ -0,0 +1,6 @@
+export enum WorkspaceApiOperations {
+  Creating,
+  Inviting,
+  Accepting,
+  ListingWorkspaces,
+}

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

@@ -0,0 +1,255 @@
+import { 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 { WorkspaceServerInterface } from '../../Server/Workspace/WorkspaceServerInterface'
+
+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>)
+  })
+
+  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]',
+    })
+
+    expect(response).toEqual({
+      data: {
+        uuid: 'i-1-2-3',
+      },
+    })
+    expect(workspaceServer.inviteToWorkspace).toHaveBeenCalledWith({
+      workspaceUuid: 'w-1-2-3',
+      inviteeEmail: '[email protected]',
+    })
+  })
+
+  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]',
+      })
+    } 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]',
+      })
+    } 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()
+  })
+})

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

@@ -0,0 +1,113 @@
+import { Uuid, WorkspaceType } from '@standardnotes/common'
+
+import { ErrorMessage } from '../../Error/ErrorMessage'
+import { ApiCallError } from '../../Error/ApiCallError'
+import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
+import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
+import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
+import { WorkspaceServerInterface } from '../../Server/Workspace/WorkspaceServerInterface'
+import { WorkspaceListResponse } from '../../Response/Workspace/WorkspaceListResponse'
+
+import { WorkspaceApiServiceInterface } from './WorkspaceApiServiceInterface'
+import { WorkspaceApiOperations } from './WorkspaceApiOperations'
+
+export class WorkspaceApiService implements WorkspaceApiServiceInterface {
+  private operationsInProgress: Map<WorkspaceApiOperations, boolean>
+
+  constructor(private workspaceServer: WorkspaceServerInterface) {
+    this.operationsInProgress = new Map()
+  }
+
+  async listWorkspaces(): Promise<WorkspaceListResponse> {
+    this.lockOperation(WorkspaceApiOperations.ListingWorkspaces)
+
+    try {
+      const response = await this.workspaceServer.listWorkspaces({})
+
+      this.unlockOperation(WorkspaceApiOperations.ListingWorkspaces)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    }
+  }
+
+  async acceptInvite(dto: {
+    inviteUuid: string
+    userUuid: string
+    publicKey: string
+    encryptedPrivateKey: string
+  }): Promise<WorkspaceInvitationAcceptingResponse> {
+    this.lockOperation(WorkspaceApiOperations.Accepting)
+
+    try {
+      const response = await this.workspaceServer.acceptInvite({
+        encryptedPrivateKey: dto.encryptedPrivateKey,
+        publicKey: dto.publicKey,
+        inviteUuid: dto.inviteUuid,
+        userUuid: dto.userUuid,
+      })
+
+      this.unlockOperation(WorkspaceApiOperations.Accepting)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    }
+  }
+
+  async inviteToWorkspace(dto: { inviteeEmail: string; workspaceUuid: Uuid }): Promise<WorkspaceInvitationResponse> {
+    this.lockOperation(WorkspaceApiOperations.Inviting)
+
+    try {
+      const response = await this.workspaceServer.inviteToWorkspace({
+        inviteeEmail: dto.inviteeEmail,
+        workspaceUuid: dto.workspaceUuid,
+      })
+
+      this.unlockOperation(WorkspaceApiOperations.Inviting)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    }
+  }
+
+  async createWorkspace(dto: {
+    workspaceType: WorkspaceType
+    encryptedWorkspaceKey?: string
+    encryptedPrivateKey?: string
+    publicKey?: string
+    workspaceName?: string
+  }): Promise<WorkspaceCreationResponse> {
+    this.lockOperation(WorkspaceApiOperations.Creating)
+
+    try {
+      const response = await this.workspaceServer.createWorkspace({
+        workspaceType: dto.workspaceType,
+        encryptedPrivateKey: dto.encryptedPrivateKey,
+        encryptedWorkspaceKey: dto.encryptedWorkspaceKey,
+        publicKey: dto.publicKey,
+        workspaceName: dto.workspaceName,
+      })
+
+      this.unlockOperation(WorkspaceApiOperations.Creating)
+
+      return response
+    } catch (error) {
+      throw new ApiCallError(ErrorMessage.GenericFail)
+    }
+  }
+
+  private lockOperation(operation: WorkspaceApiOperations): void {
+    if (this.operationsInProgress.get(operation)) {
+      throw new ApiCallError(ErrorMessage.GenericInProgress)
+    }
+
+    this.operationsInProgress.set(operation, true)
+  }
+
+  private unlockOperation(operation: WorkspaceApiOperations): void {
+    this.operationsInProgress.set(operation, false)
+  }
+}

packages/api/src/Domain/Client/Workspace/WorkspaceApiServiceInterface.ts

@@ -0,0 +1,24 @@
+import { Uuid, WorkspaceType } from '@standardnotes/common'
+
+import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
+import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
+import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
+import { WorkspaceListResponse } from '../../Response/Workspace/WorkspaceListResponse'
+
+export interface WorkspaceApiServiceInterface {
+  createWorkspace(dto: {
+    workspaceType: WorkspaceType
+    encryptedWorkspaceKey?: string
+    encryptedPrivateKey?: string
+    publicKey?: string
+    workspaceName?: string
+  }): Promise<WorkspaceCreationResponse>
+  inviteToWorkspace(dto: { inviteeEmail: string; workspaceUuid: Uuid }): Promise<WorkspaceInvitationResponse>
+  acceptInvite(dto: {
+    inviteUuid: Uuid
+    userUuid: Uuid
+    publicKey: string
+    encryptedPrivateKey: string
+  }): Promise<WorkspaceInvitationAcceptingResponse>
+  listWorkspaces(): Promise<WorkspaceListResponse>
+}

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

@@ -3,3 +3,7 @@ export * from './Subscription/SubscriptionApiService'
 export * from './Subscription/SubscriptionApiServiceInterface'
 export * from './User/UserApiService'
 export * from './User/UserApiServiceInterface'
+export * from './WebSocket/WebSocketApiService'
+export * from './WebSocket/WebSocketApiServiceInterface'
+export * from './Workspace/WorkspaceApiService'
+export * from './Workspace/WorkspaceApiServiceInterface'

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

@@ -5,5 +5,6 @@ export enum HttpStatusCode {
   BadRequest = 400,
   Unauthorized = 401,
   Forbidden = 403,
+  Gone = 410,
   ExpiredAccessToken = 498,
 }

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

@@ -8,4 +8,6 @@ export type UserRegistrationRequestParams = AnyKeyParamsContent & {
   email: string
   ephemeral: boolean
   [additionalParam: string]: unknown
+  pkcPublicKey?: string
+  pkcEncryptedPrivateKey?: string
 }

packages/api/src/Domain/Request/WebSocket/WebSocketConnectionTokenRequestParams.ts

@@ -0,0 +1,3 @@
+export type WebSocketConnectionTokenRequestParams = {
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Workspace/WorkspaceCreationRequestParams.ts

@@ -0,0 +1,10 @@
+import { WorkspaceType } from '@standardnotes/common'
+
+export type WorkspaceCreationRequestParams = {
+  workspaceType: WorkspaceType
+  encryptedWorkspaceKey?: string
+  encryptedPrivateKey?: string
+  publicKey?: string
+  workspaceName?: string
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Workspace/WorkspaceInvitationAcceptingRequestParams.ts

@@ -0,0 +1,9 @@
+import { Uuid } from '@standardnotes/common'
+
+export type WorkspaceInvitationAcceptingRequestParams = {
+  inviteUuid: Uuid
+  userUuid: Uuid
+  publicKey: string
+  encryptedPrivateKey: string
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Workspace/WorkspaceInvitationRequestParams.ts

@@ -0,0 +1,7 @@
+import { Uuid } from '@standardnotes/common'
+
+export type WorkspaceInvitationRequestParams = {
+  workspaceUuid: Uuid
+  inviteeEmail: string
+  [additionalParam: string]: unknown
+}

packages/api/src/Domain/Request/Workspace/WorkspaceListRequestParams.ts

@@ -0,0 +1,3 @@
+export type WorkspaceListRequestParams = {
+  [additionalParam: string]: unknown
+}

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

@@ -5,3 +5,8 @@ export * from './Subscription/SubscriptionInviteDeclineRequestParams'
 export * from './Subscription/SubscriptionInviteListRequestParams'
 export * from './Subscription/SubscriptionInviteRequestParams'
 export * from './User/UserRegistrationRequestParams'
+export * from './WebSocket/WebSocketConnectionTokenRequestParams'
+export * from './Workspace/WorkspaceCreationRequestParams'
+export * from './Workspace/WorkspaceInvitationAcceptingRequestParams'
+export * from './Workspace/WorkspaceInvitationRequestParams'
+export * from './Workspace/WorkspaceListRequestParams'

packages/api/src/Domain/Response/WebSocket/WebSocketConnectionTokenResponse.ts

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

packages/api/src/Domain/Response/WebSocket/WebSocketConnectionTokenResponseBody.ts

@@ -0,0 +1,3 @@
+export type WebSocketConnectionTokenResponseBody = {
+  token: string
+}

packages/api/src/Domain/Response/Workspace/WorkspaceCreationResponse.ts

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

packages/api/src/Domain/Response/Workspace/WorkspaceCreationResponseBody.ts

@@ -0,0 +1,3 @@
+export type WorkspaceCreationResponseBody = {
+  uuid: string
+}

packages/api/src/Domain/Response/Workspace/WorkspaceInvitationAcceptingResponse.ts

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

packages/api/src/Domain/Response/Workspace/WorkspaceInvitationAcceptingResponseBody.ts

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

packages/api/src/Domain/Response/Workspace/WorkspaceInvitationResponse.ts

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

packages/api/src/Domain/Response/Workspace/WorkspaceInvitationResponseBody.ts

@@ -0,0 +1,3 @@
+export type WorkspaceInvitationResponseBody = {
+  uuid: string
+}

packages/api/src/Domain/Response/Workspace/WorkspaceListResponse.ts

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

packages/api/src/Domain/Response/Workspace/WorkspaceListResponseBody.ts

@@ -0,0 +1,6 @@
+import { Workspace } from '@standardnotes/models'
+
+export type WorkspaceListResponseBody = {
+  ownedWorkspaces: Array<Workspace>
+  joinedWorkspaces: Array<Workspace>
+}

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

@@ -10,3 +10,13 @@ export * from './Subscription/SubscriptionInviteResponse'
 export * from './Subscription/SubscriptionInviteResponseBody'
 export * from './User/UserRegistrationResponse'
 export * from './User/UserRegistrationResponseBody'
+export * from './WebSocket/WebSocketConnectionTokenResponse'
+export * from './WebSocket/WebSocketConnectionTokenResponseBody'
+export * from './Workspace/WorkspaceCreationResponse'
+export * from './Workspace/WorkspaceCreationResponseBody'
+export * from './Workspace/WorkspaceInvitationAcceptingResponse'
+export * from './Workspace/WorkspaceInvitationAcceptingResponseBody'
+export * from './Workspace/WorkspaceInvitationResponse'
+export * from './Workspace/WorkspaceInvitationResponseBody'
+export * from './Workspace/WorkspaceListResponse'
+export * from './Workspace/WorkspaceListResponseBody'

packages/api/src/Domain/Server/WebSocket/Paths.ts

@@ -0,0 +1,9 @@
+const TokenPaths = {
+  createConnectionToken: '/v1/sockets/tokens',
+}
+
+export const Paths = {
+  v1: {
+    ...TokenPaths,
+  },
+}

packages/api/src/Domain/Server/WebSocket/WebSocketServer.spec.ts

@@ -0,0 +1,27 @@
+import { HttpServiceInterface } from '../../Http'
+import { WebSocketConnectionTokenResponse } from '../../Response'
+
+import { WebSocketServer } from './WebSocketServer'
+
+describe('WebSocketServer', () => {
+  let httpService: HttpServiceInterface
+
+  const createServer = () => new WebSocketServer(httpService)
+
+  beforeEach(() => {
+    httpService = {} as jest.Mocked<HttpServiceInterface>
+    httpService.post = jest.fn().mockReturnValue({
+      data: { token: 'foobar' },
+    } as jest.Mocked<WebSocketConnectionTokenResponse>)
+  })
+
+  it('should create a websocket connection token', async () => {
+    const response = await createServer().createConnectionToken({})
+
+    expect(response).toEqual({
+      data: {
+        token: 'foobar',
+      },
+    })
+  })
+})

packages/api/src/Domain/Server/WebSocket/WebSocketServer.ts

@@ -0,0 +1,17 @@
+import { HttpServiceInterface } from '../../Http/HttpServiceInterface'
+import { WebSocketConnectionTokenRequestParams } from '../../Request/WebSocket/WebSocketConnectionTokenRequestParams'
+import { WebSocketConnectionTokenResponse } from '../../Response/WebSocket/WebSocketConnectionTokenResponse'
+import { Paths } from './Paths'
+import { WebSocketServerInterface } from './WebSocketServerInterface'
+
+export class WebSocketServer implements WebSocketServerInterface {
+  constructor(private httpService: HttpServiceInterface) {}
+
+  async createConnectionToken(
+    params: WebSocketConnectionTokenRequestParams,
+  ): Promise<WebSocketConnectionTokenResponse> {
+    const response = await this.httpService.post(Paths.v1.createConnectionToken, params)
+
+    return response as WebSocketConnectionTokenResponse
+  }
+}

packages/api/src/Domain/Server/WebSocket/WebSocketServerInterface.ts

@@ -0,0 +1,6 @@
+import { WebSocketConnectionTokenRequestParams } from '../../Request/WebSocket/WebSocketConnectionTokenRequestParams'
+import { WebSocketConnectionTokenResponse } from '../../Response/WebSocket/WebSocketConnectionTokenResponse'
+
+export interface WebSocketServerInterface {
+  createConnectionToken(params: WebSocketConnectionTokenRequestParams): Promise<WebSocketConnectionTokenResponse>
+}

packages/api/src/Domain/Server/Workspace/Paths.ts

@@ -0,0 +1,14 @@
+import { Uuid } from '@standardnotes/common'
+
+const WorkspacePaths = {
+  createWorkspace: '/v1/workspaces',
+  listWorkspaces: '/v1/workspaces',
+  inviteToWorkspace: (uuid: Uuid) => `/v1/workspaces/${uuid}/invites`,
+  acceptInvite: (uuid: Uuid) => `/v1/invites/${uuid}/accept`,
+}
+
+export const Paths = {
+  v1: {
+    ...WorkspacePaths,
+  },
+}

packages/api/src/Domain/Server/Workspace/WorkspaceServer.spec.ts

@@ -0,0 +1,86 @@
+import { WorkspaceType } from '@standardnotes/common'
+import { HttpServiceInterface, 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 { WorkspaceServer } from './WorkspaceServer'
+
+describe('WorkspaceServer', () => {
+  let httpService: HttpServiceInterface
+
+  const createServer = () => new WorkspaceServer(httpService)
+
+  beforeEach(() => {
+    httpService = {} as jest.Mocked<HttpServiceInterface>
+    httpService.post = jest.fn().mockReturnValue({
+      data: { uuid: '1-2-3' },
+    } as jest.Mocked<WorkspaceCreationResponse>)
+  })
+
+  it('should create a workspace', async () => {
+    const response = await createServer().createWorkspace({
+      workspaceType: WorkspaceType.Private,
+      encryptedPrivateKey: 'foo',
+      encryptedWorkspaceKey: 'bar',
+      publicKey: 'buzz',
+    })
+
+    expect(response).toEqual({
+      data: {
+        uuid: '1-2-3',
+      },
+    })
+  })
+
+  it('should inivte to a workspace', async () => {
+    httpService.post = jest.fn().mockReturnValue({
+      data: { uuid: 'i-1-2-3' },
+    } as jest.Mocked<WorkspaceInvitationResponse>)
+
+    const response = await createServer().inviteToWorkspace({
+      inviteeEmail: '[email protected]',
+      workspaceUuid: 'w-1-2-3',
+    })
+
+    expect(response).toEqual({
+      data: {
+        uuid: 'i-1-2-3',
+      },
+    })
+  })
+
+  it('should accept invitation to a workspace', async () => {
+    httpService.post = jest.fn().mockReturnValue({
+      data: { success: true },
+    } as jest.Mocked<WorkspaceInvitationAcceptingResponse>)
+
+    const response = await createServer().acceptInvite({
+      encryptedPrivateKey: 'foo',
+      inviteUuid: 'i-1-2-3',
+      publicKey: 'bar',
+      userUuid: 'u-1-2-3',
+    })
+
+    expect(response).toEqual({
+      data: {
+        success: true,
+      },
+    })
+  })
+
+  it('should list workspaces', async () => {
+    httpService.get = jest.fn().mockReturnValue({
+      status: HttpStatusCode.Success,
+      data: { ownedWorkspaces: [], joinedWorkspaces: [] },
+    } as jest.Mocked<WorkspaceListResponse>)
+
+    const response = await createServer().listWorkspaces({})
+
+    expect(response).toEqual({
+      status: 200,
+      data: { ownedWorkspaces: [], joinedWorkspaces: [] },
+    })
+  })
+})

packages/api/src/Domain/Server/Workspace/WorkspaceServer.ts

@@ -0,0 +1,40 @@
+import { HttpServiceInterface } from '../../Http/HttpServiceInterface'
+import { WorkspaceInvitationRequestParams } from '../../Request/Workspace/WorkspaceInvitationRequestParams'
+import { WorkspaceCreationRequestParams } from '../../Request/Workspace/WorkspaceCreationRequestParams'
+import { WorkspaceInvitationResponse } from '../../Response/Workspace/WorkspaceInvitationResponse'
+import { WorkspaceCreationResponse } from '../../Response/Workspace/WorkspaceCreationResponse'
+import { WorkspaceInvitationAcceptingRequestParams } from '../../Request/Workspace/WorkspaceInvitationAcceptingRequestParams'
+import { WorkspaceInvitationAcceptingResponse } from '../../Response/Workspace/WorkspaceInvitationAcceptingResponse'
+import { WorkspaceListRequestParams } from '../../Request/Workspace/WorkspaceListRequestParams'
+import { WorkspaceListResponse } from '../../Response/Workspace/WorkspaceListResponse'
+
+import { Paths } from './Paths'
+import { WorkspaceServerInterface } from './WorkspaceServerInterface'
+
+export class WorkspaceServer implements WorkspaceServerInterface {
+  constructor(private httpService: HttpServiceInterface) {}
+
+  async listWorkspaces(params: WorkspaceListRequestParams): Promise<WorkspaceListResponse> {
+    const response = await this.httpService.get(Paths.v1.listWorkspaces, params)
+
+    return response as WorkspaceListResponse
+  }
+
+  async acceptInvite(params: WorkspaceInvitationAcceptingRequestParams): Promise<WorkspaceInvitationAcceptingResponse> {
+    const response = await this.httpService.post(Paths.v1.acceptInvite(params.inviteUuid), params)
+
+    return response as WorkspaceInvitationAcceptingResponse
+  }
+
+  async inviteToWorkspace(params: WorkspaceInvitationRequestParams): Promise<WorkspaceInvitationResponse> {
+    const response = await this.httpService.post(Paths.v1.inviteToWorkspace(params.workspaceUuid), params)
+
+    return response as WorkspaceInvitationResponse
+  }
+
+  async createWorkspace(params: WorkspaceCreationRequestParams): Promise<WorkspaceCreationResponse> {
+    const response = await this.httpService.post(Paths.v1.createWorkspace, params)
+
+    return response as WorkspaceCreationResponse
+  }
+}