Simplify createSimulation and destroySimulation (#174)

* remove createSimulation from effects

* remove simulation from state on teardown

* add changeSet

* fix changeset

* Update packages/server/src/operation-context.ts

Co-authored-by: Charles Lowell <cowboyd@frontside.com>

* remove createSimulation from effects

* type task

* remove defaultCommandTimeout from cypress.json

* remove defaultCommandTimeout from cypress.json

Co-authored-by: Charles Lowell <cowboyd@frontside.com>

Author: dagda1

.changes/simplify-create-simulation.md

@@ -0,0 +1,4 @@
+---
+"@simulacrum/server": minor
+---
+Simplify createSimulation and destroySimulation by removing them from the effects.

packages/server/src/effects.ts

@@ -0,0 +1,73 @@
+import { Task } from 'effection';
+import { ServerState, SimulationOptions, SimulationState, Simulator } from './interfaces';
+import { OperationContext } from './schema/context';
+import { v4 } from 'uuid';
+import { Slice } from '@effection/atom';
+import { createSimulation } from './simulation';
+
+type NewId = (() => string) | typeof v4;
+
+export function createOperationContext(atom: Slice<ServerState>, scope: Task, newid: NewId, simulators: Record<string, Simulator>): OperationContext {
+  let simulationsMap = new Map<string, Task>();
+
+  return {
+    atom,
+    scope,
+    async createSimulation(
+      simulator: string,
+      options: SimulationOptions,
+      debug: boolean
+    ): Promise<SimulationState> {
+      let simulationId = options.key ?? newid();
+      let existing = simulationsMap.get(simulationId);
+
+      if (!!existing) {
+        await existing.halt();
+      }
+
+      let slice = atom.slice("simulations", simulationId);
+
+      slice.set({
+        id:simulationId,
+        status: 'new',
+        simulator,
+        options,
+        services: [],
+        scenarios: {},
+        store: {},
+        debug,
+      });
+
+      await scope.run(function*() {
+        let simulationTask: Task = yield scope.spawn(function* () {
+          yield createSimulation(slice, simulators);
+
+          try {
+            yield;
+          } finally {
+            simulationsMap.delete(simulationId);
+            slice.remove();
+          }
+        });
+
+        simulationsMap.set(simulationId, simulationTask);
+
+        yield slice.filter(({ status }) => status === 'running').expect();
+      });
+
+      return slice.get();
+    },
+    async destroySimulation(simulationId: string) {
+      let simulation = simulationsMap.get(simulationId);
+
+      if(!simulation) {
+        return false;
+      }
+
+      await simulation.halt();
+
+      return true;
+    },
+    newid
+  };
+}

packages/server/src/operation-context.ts

@@ -1,9 +1,14 @@
 import { Slice } from '@effection/atom';
 import { Task } from 'effection';
-import { ServerState } from '../interfaces';
+import { ServerState, SimulationOptions, SimulationState } from '../interfaces';
 
 export interface OperationContext {
   scope: Task;
   atom: Slice<ServerState>;
+  createSimulation(
+    simulator: string,
+    options: SimulationOptions,
+    debug: boolean): Promise<SimulationState>;
+  destroySimulation(id: string): Promise<boolean>;
   newid(): string;
 }

packages/server/src/schema/context.ts

@@ -22,46 +22,14 @@ export interface CreateSimulationParameters {
 export const createSimulation: Resolver<CreateSimulationParameters, SimulationState> = {
   async resolve(args, ctx) {
     let { simulator, options = {}, debug = false } = args;
-    let { atom, scope, newid } = ctx;
 
-    let id = options.key ?? newid();
-
-    let simulation = atom.slice("simulations", id);
-
-    if(simulation.get()?.status === 'running') {
-      await destroySimulation.resolve({ id }, ctx);
-    }
-
-    if(['halted', 'destroying'].includes(simulation.get()?.status)) {
-      await scope.run(simulation.filter((sim) => typeof sim === 'undefined').expect());
-    }
-
-    simulation.set({
-      id,
-      status: 'new',
-      simulator,
-      options,
-      services: [],
-      scenarios: {},
-      store: {},
-      debug,
-    });
-
-    return scope.run(simulation.filter(({ status }) => status !== 'new').expect());
+    return await ctx.createSimulation(simulator, options, debug);
   }
 };
 
 export const destroySimulation: Resolver<{ id: string }, boolean> = {
-  async resolve({ id }, { atom, scope }) {
-    let simulation = atom.slice("simulations", id);
-    if (simulation.get()) {
-      simulation.slice("status").set("destroying");
-      await scope.run(simulation.filter(({ status }) => status == "halted").expect());
-      simulation.remove();
-      return true;
-    } else {
-      return false;
-    }
+  async resolve({ id }, { destroySimulation }) {
+    return await destroySimulation(id);
   }
 };
 

packages/server/src/schema/resolvers.ts

@@ -7,14 +7,14 @@ import { v4 } from 'uuid';
 import { schema } from './schema/schema';
 import { ServerOptions, ServerState } from './interfaces';
 import { Server, createServer } from './http';
-import { OperationContext } from './schema/context';
 
 export { Server, createServer } from './http';
 
-import { createEffects } from './effects';
 import { stableIds } from './faker';
 import { createWebSocketTransport } from './websocket-transport';
 import { Resource } from 'effection';
+import { createOperationContext } from './operation-context';
+import { createLogger } from './effects/logging';
 
 const defaults = {
   simulators: {},
@@ -33,7 +33,7 @@ export function createSimulationServer(options: ServerOptions = defaults): Resou
         simulations: {}
       });
 
-      let context: OperationContext = { atom, scope, newid };
+      let context = createOperationContext(atom, scope, newid, simulators);
 
       let app = express()
         .use(cors())
@@ -45,7 +45,7 @@ export function createSimulationServer(options: ServerOptions = defaults): Resou
 
       yield createWebSocketTransport(context, server.http);
 
-      yield createEffects(atom, simulators);
+      yield createLogger(atom);
 
       return server;
     }

packages/server/src/server.ts

@@ -1,4 +1,4 @@
-import { label, spawn } from 'effection';
+import { label, Operation, spawn, Task } from 'effection';
 import { assert } from 'assert-ts';
 import { Effect, map } from './effect';
 import express, { raw } from 'express';
@@ -69,7 +69,7 @@ function normalizeServiceCreator(service: ServiceCreator): ResourceServiceCreato
   };
 }
 
-function createSimulation (slice: Slice<SimulationState>, simulators: Record<string, Simulator>) {
+export function createSimulation (slice: Slice<SimulationState>, simulators: Record<string, Simulator>): Operation<Task<void>> {
   return spawn(function* () {
     try {
       yield function * errorBoundary() {

packages/server/src/simulation.ts

@@ -15,7 +15,7 @@ import { OperationContext } from './schema/context';
  */
 
 
-export function createWebSocketTransport({ atom, newid }: OperationContext, server: HTTPServer): Resource<void> {
+export function createWebSocketTransport(context: OperationContext, server: HTTPServer): Resource<void> {
   return {
     *init(scope) {
       let transport = makeServer<Task>({
@@ -29,8 +29,7 @@ export function createWebSocketTransport({ atom, newid }: OperationContext, serv
             variableValues,
             document: parse(message.payload.query),
             contextValue: {
-              atom,
-              newid,
+              ...context,
               scope: extra
             }
           };

packages/server/src/websocket-transport.ts

@@ -21,7 +21,7 @@ describe('person simulator', () => {
       simulation = yield client.createSimulation("person");
     });
 
-    describe('positing a person', () => {
+    describe('posting a person', () => {
       let person: Scenario<{ name: string}>;
         beforeEach(function*() {
           person = yield client.given(simulation, "person");