feat: extract functionality to Workspace class

src/api.ts

@@ -16,7 +16,7 @@ import {
     ExecutionStatus,
     ExperimentId,
     ExperimentTrajectories,
-    Workspace,
+    WorkspaceDefinition,
     WorkspaceId,
 } from './types'
 
@@ -264,7 +264,7 @@ class Api {
         await this.ensureAxiosConfig()
     }
 
-    getWorkspaces(): Promise<Workspace[]> {
+    getWorkspaces(): Promise<WorkspaceDefinition[]> {
         return new Promise((resolve, reject) => {
             this.ensureImpactToken()
                 .then(() => {

src/client.ts

@@ -1,7 +1,6 @@
-import { CaseId, CustomFunction, Workspace, WorkspaceId } from './types'
 import Api from './api'
-import Experiment from './experiment'
-import ExperimentDefinition from './experiment-definition'
+import Workspace from './workspace'
+import { WorkspaceDefinition, WorkspaceId } from './types'
 
 class Client {
     private api: Api
@@ -50,26 +49,17 @@ class Client {
         return new Client(api)
     }
 
-    getWorkspaces(): Promise<Workspace[]> {
+    getWorkspaces(): Promise<WorkspaceDefinition[]> {
         return this.api.getWorkspaces()
     }
 
-    private async createExperiment({
-        experimentDefinition,
-        workspaceId,
-    }: {
-        experimentDefinition: ExperimentDefinition
-        workspaceId: WorkspaceId
-    }): Promise<Experiment> {
-        const experimentId = await this.api.createExperiment({
-            experimentDefinition,
-            workspaceId,
-        })
-        return new Experiment({
-            api: this.api,
-            id: experimentId,
-            workspaceId,
-        })
+    async getWorkspace(workspaceId: WorkspaceId): Promise<Workspace> {
+        const workspaces = await this.getWorkspaces()
+
+        if (workspaces.find((ws) => ws.id === workspaceId)) {
+            return new Workspace({ api: this.api, id: workspaceId })
+        }
+        throw new Error(`Workspace "${workspaceId}" not found.`)
     }
 
     async createWorkspace({
@@ -78,67 +68,18 @@ class Client {
     }: {
         description?: string
         name: string
-    }): Promise<WorkspaceId> {
-        return await this.api.createWorkspace({
+    }): Promise<Workspace> {
+        const workspaceId = await this.api.createWorkspace({
             description,
             name,
         })
+
+        return new Workspace({ api: this.api, id: workspaceId })
     }
 
     async deleteWorkspace(workspaceId: WorkspaceId): Promise<void> {
         return await this.api.deleteWorkspace(workspaceId)
     }
-
-    async executeExperiment({
-        caseIds,
-        experimentDefinition,
-        workspaceId,
-    }: {
-        caseIds: CaseId[]
-        experimentDefinition: ExperimentDefinition
-        workspaceId: WorkspaceId
-    }): Promise<Experiment> {
-        const experiment = await this.createExperiment({
-            experimentDefinition,
-            workspaceId,
-        })
-
-        await this.api.runExperiment({
-            cases: caseIds,
-            experimentId: experiment.id,
-            workspaceId,
-        })
-
-        return new Experiment({
-            api: this.api,
-            id: experiment.id,
-            workspaceId,
-        })
-    }
-
-    async executeExperimentSync({
-        caseIds,
-        experimentDefinition,
-        workspaceId,
-    }: {
-        caseIds: CaseId[]
-        experimentDefinition: ExperimentDefinition
-        workspaceId: WorkspaceId
-    }): Promise<Experiment> {
-        const experiment = await this.createExperiment({
-            experimentDefinition,
-            workspaceId,
-        })
-
-        await experiment.run(caseIds)
-        await experiment.executionDone()
-
-        return experiment
-    }
-
-    getCustomFunctions(workspaceId: WorkspaceId): Promise<CustomFunction[]> {
-        return this.api.getCustomFunctions(workspaceId)
-    }
 }
 
 export default Client

src/index.ts

@@ -19,8 +19,9 @@ import {
     ModelicaExperimentExtensions,
     ModelicaExperimentModifiers,
     ModelicaExperimentParameters,
-    Workspace,
+    WorkspaceDefinition,
 } from './types/index.d'
+import Workspace from './workspace'
 
 export {
     Api,
@@ -43,4 +44,5 @@ export {
     ServerNotStarted,
     UnknownApiError,
     Workspace,
+    WorkspaceDefinition,
 }

src/types/index.d.ts

@@ -8,7 +8,7 @@ export type CustomFunction =
 export type ExecutionStatus =
     operations['getExecutionStatus']['responses']['200']['content']['application/json']
 
-export type Workspace = components['schemas']['Workspace']
+export type WorkspaceDefinition = components['schemas']['Workspace']
 
 export type ModelicaExperimentDefinition =
     components['schemas']['ExperimentDefinition']

src/workspace.ts

@@ -0,0 +1,71 @@
+import { CaseId, CustomFunction, WorkspaceId } from './types'
+import Api from './api'
+import Experiment from './experiment'
+import ExperimentDefinition from './experiment-definition'
+
+class Workspace {
+    private api: Api
+    id: WorkspaceId
+
+    constructor({ api, id }: { api: Api; id: WorkspaceId }) {
+        this.api = api
+        this.id = id
+    }
+
+    private async createExperiment(
+        experimentDefinition: ExperimentDefinition
+    ): Promise<Experiment> {
+        const experimentId = await this.api.createExperiment({
+            experimentDefinition,
+            workspaceId: this.id,
+        })
+        return new Experiment({
+            api: this.api,
+            id: experimentId,
+            workspaceId: this.id,
+        })
+    }
+
+    async executeExperiment({
+        caseIds,
+        experimentDefinition,
+    }: {
+        caseIds: CaseId[]
+        experimentDefinition: ExperimentDefinition
+    }): Promise<Experiment> {
+        const experiment = await this.createExperiment(experimentDefinition)
+
+        await this.api.runExperiment({
+            cases: caseIds,
+            experimentId: experiment.id,
+            workspaceId: this.id,
+        })
+
+        return new Experiment({
+            api: this.api,
+            id: experiment.id,
+            workspaceId: this.id,
+        })
+    }
+
+    async executeExperimentSync({
+        caseIds,
+        experimentDefinition,
+    }: {
+        caseIds: CaseId[]
+        experimentDefinition: ExperimentDefinition
+    }): Promise<Experiment> {
+        const experiment = await this.createExperiment(experimentDefinition)
+
+        await experiment.run(caseIds)
+        await experiment.executionDone()
+
+        return experiment
+    }
+
+    getCustomFunctions(): Promise<CustomFunction[]> {
+        return this.api.getCustomFunctions(this.id)
+    }
+}
+
+export default Workspace

tests/integration/integration.test.ts

@@ -4,6 +4,7 @@ import {
     ExperimentDefinition,
     InvalidApiKey,
     JhTokenError,
+    WorkspaceDefinition,
 } from '../../dist'
 import basicExperimentDefinition from './basicExperimentDefinition.json'
 
@@ -22,17 +23,10 @@ const getClient = (options?: {
     })
 
 test('Try to use invalid impact API key', (done) => {
-    const experimentDefinition = ExperimentDefinition.from(
-        basicExperimentDefinition
-    )
     const client = getClient({ impactApiKey: 'invalid-api-key' })
 
     client
-        .executeExperimentSync({
-            caseIds: ['case_1', 'case_2'],
-            experimentDefinition,
-            workspaceId: 'non-existing-workspace',
-        })
+        .getWorkspace('non-existing-workspace')
         .then(() => {
             throw new Error('Test should have caught error')
         })
@@ -48,17 +42,10 @@ test('Try to use invalid impact API key', (done) => {
 })
 
 test('Try to use invalid jupyter hub token', (done) => {
-    const experimentDefinition = ExperimentDefinition.from(
-        basicExperimentDefinition
-    )
     const client = getClient({ jupyterHubToken: 'invalid-jh-token' })
 
     client
-        .executeExperimentSync({
-            caseIds: ['case_1', 'case_2'],
-            experimentDefinition,
-            workspaceId: 'non-existing-workspace',
-        })
+        .getWorkspace('non-existing-workspace')
         .then(() => {
             throw new Error('Test should have caught error')
         })
@@ -83,23 +70,24 @@ test(
         const client = getClient()
         const WorkspaceName = 'setup-and-exec'
 
+        let testWorkspace
         try {
-            const workspaces = await client.getWorkspaces()
-            let workspaceId
-            const testWorkspace = workspaces.find(
-                (w) => w.definition.name === WorkspaceName
-            )
-            if (testWorkspace) {
-                workspaceId = testWorkspace.id
-            } else {
-                workspaceId = await client.createWorkspace({
-                    name: WorkspaceName,
-                })
-            }
-            const experiment = await client.executeExperimentSync({
+            testWorkspace = await client.getWorkspace(WorkspaceName)
+        } catch (e) {
+            testWorkspace = await client.createWorkspace({
+                name: WorkspaceName,
+            })
+        }
+
+        const customFunctions = await testWorkspace.getCustomFunctions()
+        expect(customFunctions.length).toBeGreaterThanOrEqual(
+            ['linearize', 'dynamic', 'steady state'].length
+        )
+
+        try {
+            const experiment = await testWorkspace.executeExperimentSync({
                 caseIds: ['case_1', 'case_2'],
                 experimentDefinition,
-                workspaceId,
             })
             expect(typeof experiment).toBe('object')
 
@@ -148,7 +136,8 @@ test(
             const workspacesAfterDelete = await client.getWorkspaces()
             expect(
                 workspacesAfterDelete.find(
-                    (w) => w.definition.name === WorkspaceName
+                    (w: WorkspaceDefinition) =>
+                        w.definition.name === WorkspaceName
                 )
             ).toEqual(undefined)
         } catch (e) {