First Commit

Yes, that is what I do at 31.12.2021 at 22:39 local time...

templates/ts_service_base.ts

@@ -0,0 +1,30 @@
+export const Logging  = {
+   verbose: false,
+   log(...args: any[]) {
+      if(Logging.verbose) {
+         console.log(...args)
+      }
+   }
+}
+
+export enum ErrorCodes {
+   ParseError=-32700,
+   InvalidRequest=-32700,
+   MethodNotFound=-32700,
+   InvalidParams=-32700,
+   InternalError=-32700,
+}
+
+export interface RequestObject {
+   jsonrpc: "2.0";
+   method: string;
+   params?: any[] | { [key: string]: any };
+   id?: string | null;
+}
+
+export interface ResponseObject {
+   jsonrpc: "2.0";
+   result?: any;
+   error?: { code: ErrorCodes, message:string, data?: any}
+   id: string;
+}

templates/ts_service_client.ts

@@ -0,0 +1,93 @@
+//@template-ignore
+import { RequestObject, ResponseObject, ErrorCodes, Logging } from "./ts_service_base";
+
+
+export type IMessageCallback = (data: any) => void;
+
+export type ResponseListener = {
+   ok: (response:any)=>void;
+   err: (error: Error)=>void;
+}
+
+export class Service {
+   public _name: string = null as any;
+
+   constructor(protected _provider: ServiceProvider, name: string) {
+      this._name = name;
+      this._provider.services.set(name, this);
+   }
+}
+
+export class ServiceProvider {
+   services = new Map<string, Service>();
+   requests = new Map<string, ResponseListener>();
+
+   constructor(private sendPacket: IMessageCallback) {}
+
+   onPacket(msg: RequestObject | ResponseObject) {
+      Logging.log("CLIENT: Received message:", msg);
+      if("method" in msg) {
+         if(msg.id){ 
+            Logging.log("CLIENT: Determined type is Request");
+            // Request, which are not supported by client, so ignore
+            return;
+         } else {
+            Logging.log("CLIENT: Determined type is Notification");
+            //Notification. Send to Notification handler
+            //TODO: Implement
+         }
+      } else {
+         Logging.log("CLIENT: Determined type is Response");
+         // Response
+         let resListener = this.requests.get(msg.id);
+         if(!resListener) return; // Ignore wrong responses
+         if(msg.error) {
+            resListener.err(new Error(msg.error.message));
+         } else {
+            resListener.ok(msg.result);
+         }
+      }
+         
+   }
+
+   sendMessage(msg: RequestObject, res?: ResponseListener) {
+      Logging.log("CLIENT: Sending Messgage", msg);
+      if(msg.id) {
+         this.requests.set(msg.id, res);
+      }
+      this.sendPacket(msg)
+   }
+}
+
+
+
+
+
+
+
+declare var require: any;
+export const getRandomBytes = (
+   typeof self !== "undefined" && (self.crypto || (self as any).msCrypto)
+      ? function () {
+           // Browsers
+           var crypto = self.crypto || (self as any).msCrypto;
+           var QUOTA = 65536;
+           return function (n: number) {
+              var a = new Uint8Array(n);
+              for (var i = 0; i < n; i += QUOTA) {
+                 crypto.getRandomValues(
+                    a.subarray(i, i + Math.min(n - i, QUOTA))
+                 );
+              }
+              return a;
+           };
+        }
+      : function () {
+           // Node
+           return require("crypto").randomBytes;
+        }
+)() as (cnt: number) => Uint8Array;
+
+export const getRandomID = (length: number) => {
+   return btoa(String.fromCharCode.apply(null, getRandomBytes(length) as any));
+};

templates/ts_service_server.ts

@@ -0,0 +1,120 @@
+//@template-ignore
+import { RequestObject, ResponseObject, ErrorCodes, Logging } from "./ts_service_base";
+
+
+export class Service<T> {
+   public name: string = null as any;
+   public functions = new Set<string>();
+
+   constructor() {}
+}
+
+type ISendMessageCB = (data: any, catchedErr?: Error) => void;
+
+export class ServiceProvider<T = any> {
+   services = new Map<string, Service<T>>();
+   addService(service: Service<T>) {
+      this.services.set(service.name, service);
+      Logging.log("SERVER: Adding Service to provider:", service.name);
+      Logging.log("SERVER: Service provides:", [...service.functions.keys()])
+   }
+
+   getSession(send: ISendMessageCB, ctx?: Partial<T>): Session<T> {
+      return new Session(this, send, ctx);
+   }
+}
+
+class Session<T> {
+   ctx: Partial<T>;
+
+   constructor(
+      private provider: ServiceProvider,
+      private _send: ISendMessageCB,
+      ctx?: Partial<T>
+   ) {
+      this.ctx = ctx || {};
+   }
+
+   send(data: any, catchedErr?:Error) {
+      Logging.log("SERVER: Sending Message", data)
+      this._send(data, catchedErr);
+   }
+
+   async onMessage(data: RequestObject) {
+      Logging.log("SERVER: Received Message", data);
+      try {
+         if (!data.method) {
+            if (data.id) {
+               this.send({
+                  jsonrpc: "2.0",
+                  id: data.id,
+                  error: {
+                     code: ErrorCodes.InvalidRequest,
+                     message: "No method defined!",
+                  },
+               } as ResponseObject);
+            }
+            return;
+         }
+
+         const [srvName, fncName] = data.method.split(".");
+         Logging.log("SERVER: Message for", srvName, fncName);
+
+         const service = this.provider.services.get(srvName);
+         if (!service) {
+            Logging.log("SERVER: Did not find Service");
+            if (data.id) {
+               this.send({
+                  jsonrpc: "2.0",
+                  id: data.id,
+                  error: {
+                     code: ErrorCodes.MethodNotFound,
+                     message: "Service not found!",
+                  },
+               } as ResponseObject);
+            }
+            return;
+         }
+
+         const fnc = service.functions.has(fncName);
+         if (!fnc) {
+            Logging.log("SERVER: Did not find Function");
+            if (data.id) {
+               this.send({
+                  jsonrpc: "2.0",
+                  id: data.id,
+                  error: {
+                     code: ErrorCodes.MethodNotFound,
+                     message: "Function not found!",
+                  },
+               } as ResponseObject);
+            }
+            return;
+         }
+
+         let result = await (service as any)["_" + fncName](data.params, this.ctx);
+         if(data.id) { //Request
+            this.send({
+               jsonrpc: "2.0",
+               id: data.id,
+               result: result,
+            } as ResponseObject);
+         } //else Notification and response is ignored
+      } catch (err) {
+         if (data.id) {
+            this.send(
+               {
+                  jsonrpc: "2.0",
+                  id: data.id,
+                  error: {
+                     code: ErrorCodes.InternalError,
+                     message: err.message,
+                  },
+               } as ResponseObject,
+               err
+            );
+         }
+         //TODO: Think about else case
+      }
+   }
+}