#296: added server to services

packages/services/src/Client.ts

@@ -1,6 +1,6 @@
 
-import { Request, Response, ExecutionManager, Runner } from '@jitar/execution';
-import { MiddlewareManager, ProcedureRunner } from '@jitar/middleware';
+import type { Request, Response, ExecutionManager, Runner } from '@jitar/execution';
+import { type MiddlewareManager, ProcedureRunner } from '@jitar/middleware';
 
 import RemoteGateway from './gateway/RemoteGateway';
 
@@ -27,8 +27,6 @@ export default class Client implements Runner
 
         // TODO: Should be done when constructing the middleware manager
         this.#middlewareManager.addMiddleware(new ProcedureRunner(this.#executionManager));
-
-        // TODO: Move runtime registration to the starter script
     }
 
     run(request: Request): Promise<Response>

packages/services/src/Server.ts

@@ -0,0 +1,76 @@
+
+import type { Request, Response, Runner } from '@jitar/execution';
+import type { SourcingManager } from '@jitar/sourcing';
+
+import Service from './Service';
+import RunnerService from './RunnerService';
+
+type Configuration =
+{
+    service: Service;
+    sourcingManager: SourcingManager;
+    setUpScripts?: string[];
+    tearDownScripts?: string[];
+};
+
+export default class Server implements Runner
+{
+    #service: Service;
+    #sourcingManager: SourcingManager;
+    #setUpScripts: string[];
+    #tearDownScripts: string[];
+
+    constructor(configuration: Configuration)
+    {
+        this.#service = configuration.service;
+        this.#sourcingManager = configuration.sourcingManager;
+        this.#setUpScripts = configuration.setUpScripts ?? [];
+        this.#tearDownScripts = configuration.tearDownScripts ?? [];
+    }
+
+    get service() { return this.#service; }
+
+    async start(): Promise<void>
+    {
+        await this.#setUp();
+
+        return this.#service.start();
+    }
+
+    async stop(): Promise<void>
+    {
+        await this.#service.stop();;
+
+        return this.#tearDown();
+    }
+
+    run(request: Request): Promise<Response>
+    {
+        if (this.#canNotRun())
+        {
+            throw new Error('Cannot run');
+        }
+
+        return (this.#service as RunnerService).run(request);
+    }
+
+    #canNotRun(): boolean
+    {
+        return (this.#service as RunnerService).run === undefined;
+    }
+
+    #setUp(): Promise<void>
+    {
+        return this.#runScripts(this.#setUpScripts);
+    }
+
+    #tearDown(): Promise<void>
+    {
+        return this.#runScripts(this.#tearDownScripts);
+    }
+
+    async #runScripts(scripts: string[]): Promise<void>
+    {
+        await Promise.all(scripts.map(script => this.#sourcingManager.import(script)));
+    }
+}

packages/services/src/index.ts

@@ -14,6 +14,7 @@ export { default as LocalWorker } from './worker/LocalWorker';
 export { default as RemoteWorker } from './worker/RemoteWorker';
 
 export { default as Client } from './Client';
+export { default as Server } from './Server';
 export { default as Remote } from './Remote';
 
 export { default as Service } from './Service';

packages/sourcing/src/SourcingManager.ts

@@ -4,13 +4,18 @@ import { Module, ImportFunction, ModuleNotLoaded } from './modules';
 
 export default class SourceManager
 {
-    #import: ImportFunction;
     #fileManager: FileManager;
+    #import: ImportFunction;
 
-    constructor(importFunction: ImportFunction, fileManager: FileManager)
+    constructor(fileManager: FileManager, importFunction: ImportFunction)
     {
-        this.#import = importFunction;
         this.#fileManager = fileManager;
+        this.#import = importFunction;
+    }
+
+    async read(filename: string): Promise<File>
+    {
+        return this.#fileManager.read(filename);
     }
 
     async import(specifier: string): Promise<Module>
@@ -33,9 +38,4 @@ export default class SourceManager
             throw new ModuleNotLoaded(specifier, message);
         }
     }
-
-    async read(filename: string): Promise<File>
-    {
-        return this.#fileManager.read(filename);
-    }
 }