3.0.13

.gitlab-ci.yml

@@ -12,30 +12,35 @@ stages:
   - release
   - metadata
 
+before_script:
+  - npm install -g @shipzone/npmci
+
 # ====================
 # security stage
 # ====================
-mirror:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
-    - npmci git mirror
+    - npmci npm prepare
+    - npmci command npm install --production --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=prod --production
   tags:
-    - lossless
     - docker
-    - notpriv
+  allow_failure: true
 
-audit:
+auditDevDependencies:
   image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
     - npmci command npm install --ignore-scripts
     - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high
+    - npmci command npm audit --audit-level=high --only=dev
   tags:
-    - lossless
     - docker
-    - notpriv
+  allow_failure: true
 
 # ====================
 # test stage
@@ -50,9 +55,7 @@ testStable:
     - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - priv
 
 testBuild:
   stage: test
@@ -63,9 +66,7 @@ testBuild:
     - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - notpriv
 
 release:
   stage: release
@@ -85,11 +86,12 @@ release:
 codequality:
   stage: metadata
   allow_failure: true
+  only:
+    - tags
   script:
-    - npmci command npm install -g tslint typescript
+    - npmci command npm install -g typescript
     - npmci npm prepare
     - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
     - lossless
     - docker
@@ -109,11 +111,10 @@ trigger:
 pages:
   stage: metadata
   script:
-    - npmci node install lts
-    - npmci command npm install -g @gitzone/tsdoc
+    - npmci node install stable 
     - npmci npm prepare
     - npmci npm install
-    - npmci command tsdoc
+    - npmci command npm run buildDocs
   tags:
     - lossless
     - docker

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
-      "type": "node",
+      "command": "npm test",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
+      "type": "node-terminal"
     }
   ]
 }

.vscode/settings.json

@@ -15,7 +15,7 @@
             "properties": {
               "projectType": {
                 "type": "string",
-                "enum": ["website", "element", "service", "npm"]
+                "enum": ["website", "element", "service", "npm", "wcc"]
               }
             }
           }

npmextra.json

@@ -3,10 +3,10 @@
     "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
-      "gitscope": "apiglobal",
+      "gitscope": "api.global",
       "gitrepo": "typedrequest",
-      "shortDescription": "make typed requests towards apis",
-      "npmPackagename": "@apiglobal/typedrequest",
+      "description": "make typed requests towards apis",
+      "npmPackagename": "@api.global/typedrequest",
       "license": "MIT",
       "projectDomain": "api.global"
     }

package.json

@@ -1,32 +1,37 @@
 {
-  "name": "@apiglobal/typedrequest",
-  "version": "1.0.31",
+  "name": "@api.global/typedrequest",
+  "version": "3.0.13",
   "private": false,
   "description": "make typed requests towards apis",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild --web)",
-    "format": "(gitzone format)"
+    "build": "(tsbuild --web --allowimplicitany && tsbundle npm)",
+    "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.24",
-    "@gitzone/tstest": "^1.0.33",
-    "@pushrocks/smartexpress": "^3.0.69",
-    "@pushrocks/tapbundle": "^3.2.1",
-    "@types/node": "^14.0.13",
-    "tslint": "^6.1.2",
-    "tslint-config-prettier": "^1.18.0"
+    "@api.global/typedserver": "^3.0.25",
+    "@git.zone/tsbuild": "^2.1.72",
+    "@git.zone/tsbundle": "^2.0.15",
+    "@git.zone/tsrun": "^1.2.44",
+    "@git.zone/tstest": "^1.0.86",
+    "@push.rocks/smartenv": "^5.0.12",
+    "@push.rocks/tapbundle": "^5.0.15",
+    "@types/node": "^20.11.24"
   },
   "dependencies": {
-    "@apiglobal/typedrequest-interfaces": "^1.0.13",
-    "@pushrocks/lik": "^4.0.13",
-    "@pushrocks/smartdelay": "^2.0.9",
-    "@pushrocks/smartjson": "^3.0.10",
-    "@pushrocks/smartrequest": "^1.1.47"
+    "@api.global/typedrequest-interfaces": "^3.0.18",
+    "@push.rocks/isounique": "^1.0.5",
+    "@push.rocks/lik": "^6.0.14",
+    "@push.rocks/smartbuffer": "^1.0.7",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/webrequest": "^3.0.34",
+    "@push.rocks/webstream": "^1.0.8"
   },
   "files": [
     "ts/**/*",
@@ -39,5 +44,8 @@
     "cli.js",
     "npmextra.json",
     "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
   ]
 }

readme.md

@@ -27,6 +27,76 @@ Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20W
 
 Use TypeScript for best in class intellisense.
 
+```typescript
+import { expect, tap } from '@pushrocks/tapbundle';
+import * as smartexpress from '@pushrocks/smartexpress';
+
+import * as typedrequest from '../ts/index';
+
+let testServer: smartexpress.Server;
+let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
+
+// lets define an interface
+interface ITestReqRes {
+  method: 'hi';
+  request: {
+    name: string;
+  };
+  response: {
+    surname: string;
+  };
+}
+
+tap.test('should create a typedHandler', async () => {
+  // lets use the interface in a TypedHandler
+  testTypedHandler = new typedrequest.TypedHandler<ITestReqRes>('hi', async (reqArg) => {
+    return {
+      surname: 'wow',
+    };
+  });
+});
+
+tap.test('should spawn a server to test with', async () => {
+  testServer = new smartexpress.Server({
+    cors: true,
+    forceSsl: false,
+    port: 3000,
+  });
+});
+
+tap.test('should define a testHandler', async () => {
+  const testTypedRouter = new typedrequest.TypedRouter(); // typed routers can broker typedrequests between handlers
+  testTypedRouter.addTypedHandler(testTypedHandler);
+  testServer.addRoute(
+    '/testroute',
+    new smartexpress.HandlerTypedRouter(testTypedRouter as any) // the "any" is testspecific, since smartexpress ships with its own version of typedrequest.
+  );
+});
+
+tap.test('should start the server', async () => {
+  await testServer.start();
+});
+
+tap.test('should fire a request', async () => {
+  const typedRequest = new typedrequest.TypedRequest<ITestReqRes>(
+    'http://localhost:3000/testroute',
+    'hi'
+  );
+  const response = await typedRequest.fire({
+    name: 'really',
+  });
+  console.log('this is the response:');
+  console.log(response);
+  expect(response.surname).to.equal('wow');
+});
+
+tap.test('should end the server', async () => {
+  await testServer.stop();
+});
+
+tap.start();
+```
+
 ## Contribution
 
 We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)

test/skip.ts

@@ -0,0 +1,108 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as typedserver from '@api.global/typedserver';
+
+import * as typedrequest from '../ts/index.js';
+import * as typedrequestInterfaces from '@api.global/typedrequest-interfaces';
+
+let testServer: typedserver.servertools.Server;
+let testTypedRouter: typedrequest.TypedRouter;
+let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
+
+// lets define an interface
+interface ITestReqRes {
+  method: 'hi';
+  request: {
+    name: string;
+  };
+  response: {
+    surname: string;
+  };
+}
+
+interface ITestStream {
+  method: 'handleStream';
+  request: {
+    requestStream: typedrequestInterfaces.IVirtualStream;
+  };
+  response: {
+    responseStream: typedrequestInterfaces.IVirtualStream;
+  };
+}
+
+tap.test('should create a typedHandler', async () => {
+  // lets use the interface in a TypedHandler
+  testTypedHandler = new typedrequest.TypedHandler<ITestReqRes>('hi', async (reqArg) => {
+    return {
+      surname: 'wow',
+    };
+  });
+});
+
+tap.test('should spawn a server to test with', async () => {
+  testServer = new typedserver.servertools.Server({
+    cors: true,
+    forceSsl: false,
+    port: 3000,
+  });
+});
+
+tap.test('should define a testHandler', async () => {
+  testTypedRouter = new typedrequest.TypedRouter(); // typed routers can broker typedrequests between handlers
+  testTypedRouter.addTypedHandler(testTypedHandler);
+  testServer.addRoute(
+    '/testroute',
+    new typedserver.servertools.HandlerTypedRouter(testTypedRouter as any) // the "any" is testspecific, since smartexpress ships with its own version of typedrequest.
+  );
+});
+
+tap.test('should start the server', async () => {
+  await testServer.start();
+});
+
+tap.test('should fire a request', async () => {
+  const typedRequest = new typedrequest.TypedRequest<ITestReqRes>(
+    'http://localhost:3000/testroute',
+    'hi'
+  );
+  const response = await typedRequest.fire({
+    name: 'really',
+  });
+  console.log('this is the response:');
+  console.log(response);
+  expect(response.surname).toEqual('wow');
+});
+
+tap.test('should allow VirtualStreams', async () => {
+  const newRequestingVS = new typedrequest.VirtualStream();
+  const newRespondingVS = new typedrequest.VirtualStream();
+  let generatedRequestingVS: typedrequestInterfaces.IVirtualStream;
+  let generatedRespondingVS: typedrequestInterfaces.IVirtualStream;
+  testTypedRouter.addTypedHandler(new typedrequest.TypedHandler<ITestStream>('handleStream', async (reqArg) => {
+    console.log('hey there');
+    console.log(reqArg.requestStream);
+    generatedRequestingVS = reqArg.requestStream;
+    return {
+      responseStream: newRespondingVS,
+    };
+  }));
+  const typedRequest = new typedrequest.TypedRequest<ITestStream>(
+    'http://localhost:3000/testroute',
+    'handleStream'
+  );
+  const response = await typedRequest.fire({
+    requestStream: newRequestingVS,
+  });
+  console.log(response.responseStream);
+
+  newRequestingVS.sendData(Buffer.from('hello'));
+  const data = await generatedRequestingVS.fetchData();
+  const decodedData = data.toString();
+  expect(data.toString()).toEqual('hello');
+});
+
+tap.test('should end the server', async (toolsArg) => {
+  await toolsArg.delayFor(5000);
+  await testServer.stop();
+});
+
+tap.start();

test/test.browser.ts

@@ -0,0 +1,45 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+
+import * as typedrequest from '../ts/index.js';
+
+let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
+
+// lets define an interface
+interface ITestReqRes {
+  method: 'hi';
+  request: {
+    name: string;
+  };
+  response: {
+    surname: string;
+  };
+}
+
+tap.test('should create a typedHandler', async () => {
+  // lets use the interface in a TypedHandler
+  testTypedHandler = new typedrequest.TypedHandler<ITestReqRes>('hi', async (reqArg) => {
+    return {
+      surname: 'wow',
+    };
+  });
+});
+
+tap.test('should define a testHandler', async () => {
+  const testTypedRouter = new typedrequest.TypedRouter(); // typed routers can broker typedrequests between handlers
+  testTypedRouter.addTypedHandler(testTypedHandler);
+});
+
+tap.test('should fire a request', async () => {
+  const typedRequest = new typedrequest.TypedRequest<ITestReqRes>(
+    'http://localhost:3000/typedrequest',
+    'hi'
+  );
+  const result = await typedRequest.fire({
+    name: 'yes',
+  }).catch(err => {
+    console.log(err);
+  });
+  console.log(result);
+});
+
+tap.start();

test/test.ts

@@ -1,65 +0,0 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import * as smartexpress from '@pushrocks/smartexpress';
-
-import * as typedrequest from '../ts/index';
-
-let testServer: smartexpress.Server;
-let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
-
-interface ITestReqRes {
-  method: 'hi';
-  request: {
-    name: string;
-  };
-  response: {
-    surname: string;
-  };
-}
-
-tap.test('should create a typedHandler', async () => {
-  testTypedHandler = new typedrequest.TypedHandler<ITestReqRes>('hi', async reqArg => {
-    return {
-      surname: 'wow'
-    };
-  });
-});
-
-tap.test('should spawn a server to test with', async () => {
-  testServer = new smartexpress.Server({
-    cors: true,
-    forceSsl: false,
-    port: 3000
-  });
-});
-
-tap.test('should define a testHandler', async () => {
-  testServer.addRoute(
-    '/testroute',
-    new smartexpress.Handler('POST', async (req, res) => {
-      console.log(req.body);
-      res.json(await testTypedHandler.addResponse(req.body));
-    })
-  );
-});
-
-tap.test('should start the server', async () => {
-  await testServer.start();
-});
-
-tap.test('should fire a request', async () => {
-  const typedRequest = new typedrequest.TypedRequest<ITestReqRes>(
-    'http://localhost:3000/testroute',
-    'hi'
-  );
-  const response = await typedRequest.fire({
-    name: 'really'
-  });
-  console.log(response);
-  expect(response.surname).to.equal('wow');
-});
-
-tap.test('should end the server', async () => {
-  await testServer.stop();
-});
-
-tap.start();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@api.global/typedrequest',
+  version: '3.0.13',
+  description: 'make typed requests towards apis'
+}

ts/index.ts

@@ -1,3 +1,6 @@
-export * from './typedrequest.classes.typedrequest';
-export * from './typedrequest.classes.typedhandler';
-export * from './typedrequest.classes.typedrouter';
+export * from './typedrequest.classes.typedrequest.js';
+export * from './typedrequest.classes.typedhandler.js';
+export * from './typedrequest.classes.typedrouter.js';
+export * from './typedrequest.classes.typedresponseerror.js';
+export * from './typedrequest.classes.typedtarget.js';
+export * from './typedrequest.classes.virtualstream.js';

ts/plugins.ts

@@ -0,0 +1,15 @@
+// apiglobal scope
+import * as typedRequestInterfaces from '@api.global/typedrequest-interfaces';
+
+export { typedRequestInterfaces };
+
+// pushrocks scope
+import * as isounique from '@push.rocks/isounique';
+import * as lik from '@push.rocks/lik';
+import * as smartbuffer from '@push.rocks/smartbuffer';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as webrequest from '@push.rocks/webrequest';
+import * as webstream from '@push.rocks/webstream';
+
+export { isounique, lik, smartbuffer, smartdelay, smartpromise, webrequest, webstream };

ts/typedrequest.classes.typedhandler.ts

@@ -1,6 +1,7 @@
-import * as plugins from './typedrequest.plugins';
+import * as plugins from './plugins.js';
+import { TypedResponseError } from './typedrequest.classes.typedresponseerror.js';
 
-type THandlerFunction<T extends plugins.typedRequestInterfaces.ITypedRequest> = (
+export type THandlerFunction<T extends plugins.typedRequestInterfaces.ITypedRequest> = (
   requestArg: T['request']
 ) => Promise<T['response']>;
 
@@ -26,8 +27,28 @@ export class TypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest
         'this handler has been given a wrong method to answer to. Please use a TypedRouter to filter requests'
       );
     }
-    const response = await this.handlerFunction(typedRequestArg.request);
-    typedRequestArg.response = response;
+    let typedResponseError: TypedResponseError;
+    const response = await this.handlerFunction(typedRequestArg.request).catch((e) => {
+      if (e instanceof TypedResponseError) {
+        typedResponseError = e;
+      } else {
+        console.log(e);
+      }
+    });
+
+    if (typedResponseError) {
+      typedRequestArg.error = {
+        text: typedResponseError.errorText,
+        data: typedResponseError.errorData,
+      };
+    }
+
+    if (response) {
+      typedRequestArg.response = response;
+    }
+
+    typedRequestArg?.correlation?.phase ? (typedRequestArg.correlation.phase = 'response') : null;
+
     return typedRequestArg;
   }
 }

ts/typedrequest.classes.typedrequest.ts

@@ -1,38 +1,103 @@
-import * as plugins from './typedrequest.plugins';
+import * as plugins from './plugins.js';
+import { VirtualStream } from './typedrequest.classes.virtualstream.js';
+import { TypedResponseError } from './typedrequest.classes.typedresponseerror.js';
+import { TypedRouter } from './typedrequest.classes.typedrouter.js';
+import { TypedTarget } from './typedrequest.classes.typedtarget.js';
+
+const webrequestInstance = new plugins.webrequest.WebRequest();
 
 export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest> {
-  public urlEndPoint: string;
+  /**
+   * in case we post against a url endpoint
+   */
+  public urlEndPoint?: string;
+
+  /**
+   * in case we post against a TypedTarget
+   */
+  typedTarget: TypedTarget;
+
   public method: string;
 
-  // STATIC
-  constructor(urlEndPointArg: string, methodArg: T['method']) {
-    this.urlEndPoint = urlEndPointArg;
+  /**
+   * @param postEndPointArg
+   * @param methodArg
+   */
+  constructor(postTarget: string | TypedTarget, methodArg: T['method']) {
+    if (typeof postTarget === 'string') {
+      this.urlEndPoint = postTarget;
+    } else {
+      this.typedTarget = postTarget;
+    }
     this.method = methodArg;
   }
 
   /**
-   * firest the request
+   * fires the request
    */
-  public async fire(fireArg: T['request']): Promise<T['response']> {
-    const response = await plugins.smartrequest.postJson(this.urlEndPoint, {
-      requestBody: {
-        method: this.method,
-        request: fireArg,
-        response: null
+  public async fire(fireArg: T['request'], useCacheArg: boolean = false): Promise<T['response']> {
+    let payloadSending: plugins.typedRequestInterfaces.ITypedRequest = {
+      method: this.method,
+      request: fireArg,
+      response: null,
+      correlation: {
+        id: plugins.isounique.uni(),
+        phase: 'request',
+      },
+    };
+
+    // lets preprocess the payload
+    payloadSending = VirtualStream.encodePayloadForNetwork(payloadSending, {
+      sendMethod: (payloadArg: plugins.typedRequestInterfaces.IStreamRequest) => {
+        return this.postTrObject(payloadArg) as Promise<plugins.typedRequestInterfaces.IStreamRequest>;
       }
     });
-    const responseBody: T = response.body;
-    if (responseBody.error) {
-      console.log(responseBody.error.text);
-      console.log(responseBody.error.data);
+
+    let payloadReceiving: plugins.typedRequestInterfaces.ITypedRequest;
+    payloadReceiving = await this.postTrObject(payloadSending, useCacheArg);
+
+    // lets preprocess the response
+    payloadReceiving = VirtualStream.decodePayloadFromNetwork(payloadReceiving, {
+      sendMethod: (payloadArg: plugins.typedRequestInterfaces.IStreamRequest) => {
+        return this.postTrObject(payloadArg) as Promise<plugins.typedRequestInterfaces.IStreamRequest>;
+      }
+    });
+    return payloadReceiving.response;
+  }
+
+  private async postTrObject(payloadSendingArg: plugins.typedRequestInterfaces.ITypedRequest, useCacheArg: boolean = false) {
+    let payloadReceiving: plugins.typedRequestInterfaces.ITypedRequest;
+    if (this.urlEndPoint) {
+      const response = await webrequestInstance.postJson(
+        this.urlEndPoint,
+        payloadSendingArg,
+        useCacheArg
+      );
+      payloadReceiving = response;
+    } else {
+      payloadReceiving = await this.typedTarget.post(payloadSendingArg);
+    }
+    if (payloadReceiving.error) {
+      console.error(
+        `Got an error ${payloadReceiving.error.text} with data ${JSON.stringify(
+          payloadReceiving.error.data,
+          null,
+          2
+        )}`
+      );
+      if (!payloadReceiving.retry) {
+        throw new TypedResponseError(payloadReceiving.error.text, payloadReceiving.error.data);
+      }
       return null;
     }
-    if (responseBody.retry) {
-      console.log(`server requested retry for the following reason: ${responseBody.retry.reason}`);
-      await plugins.smartdelay.delayFor(responseBody.retry.waitForMs);
+    if (payloadReceiving.retry) {
+      console.log(
+        `server requested retry for the following reason: ${payloadReceiving.retry.reason}`
+      );
+      await plugins.smartdelay.delayFor(payloadReceiving.retry.waitForMs);
       // tslint:disable-next-line: no-return-await
-      return await this.fire(fireArg);
+      payloadReceiving =  await this.postTrObject(payloadSendingArg, useCacheArg);
     }
-    return responseBody.response;
+    return payloadReceiving;
   }
 }

ts/typedrequest.classes.typedresponseerror.ts

@@ -0,0 +1,10 @@
+import * as plugins from './plugins.js';
+
+export class TypedResponseError {
+  public errorText: string;
+  public errorData: any;
+  constructor(errorTextArg: string, errorDataArg?: any) {
+    this.errorText = errorTextArg;
+    this.errorData = errorDataArg;
+  }
+}

ts/typedrequest.classes.typedrouter.ts

@@ -1,6 +1,8 @@
-import * as plugins from './typedrequest.plugins';
+import * as plugins from './plugins.js';
+import { VirtualStream } from './typedrequest.classes.virtualstream.js';
 
-import { TypedHandler } from './typedrequest.classes.typedhandler';
+import { TypedHandler } from './typedrequest.classes.typedhandler.js';
+import { TypedRequest } from './typedrequest.classes.typedrequest.js';
 
 /**
  * A typed router decides on which typed handler to call based on the method
@@ -8,13 +10,16 @@ import { TypedHandler } from './typedrequest.classes.typedhandler';
  * This is thought for reusing the same url endpoint for different methods
  */
 export class TypedRouter {
-  public upstreamTypedRouter: TypedRouter;
-
   public routerMap = new plugins.lik.ObjectMap<TypedRouter>();
-
   public handlerMap = new plugins.lik.ObjectMap<
-    TypedHandler<plugins.typedRequestInterfaces.ITypedRequest>
+    TypedHandler<any & plugins.typedRequestInterfaces.ITypedRequest>
   >();
+  public registeredVirtualStreams = new plugins.lik.ObjectMap<VirtualStream<any>>();
+
+  public fireEventInterestMap = new plugins.lik.InterestMap<
+    string,
+    plugins.typedRequestInterfaces.ITypedRequest
+  >((correlationId: string) => correlationId);
 
   /**
    * adds the handler to the routing map
@@ -39,11 +44,11 @@ export class TypedRouter {
    * @param typedRequest
    */
   public addTypedRouter(typedRouterArg: TypedRouter) {
-    this.routerMap.add(typedRouterArg);
-  }
-
-  public setUpstreamTypedRouter(typedRouterArg: TypedRouter) {
-    this.upstreamTypedRouter = typedRouterArg;
+    const routerExists = this.routerMap.findSync((routerArg) => routerArg === typedRouterArg);
+    if (!routerExists) {
+      this.routerMap.add(typedRouterArg);
+      typedRouterArg.addTypedRouter(this);
+    }
   }
 
   public checkForTypedHandler(methodArg: string): boolean {
@@ -57,52 +62,105 @@ export class TypedRouter {
    */
   public getTypedHandlerForMethod(
     methodArg: string,
-    checkUpstreamRouter = true
+    checkedRouters: TypedRouter[] = []
   ): TypedHandler<any> {
+    checkedRouters.push(this);
+
     let typedHandler: TypedHandler<any>;
 
-    if (this.upstreamTypedRouter && checkUpstreamRouter) {
-      typedHandler = this.upstreamTypedRouter.getTypedHandlerForMethod(methodArg);
-    } else {
-      typedHandler = this.handlerMap.find(handler => {
-        return handler.method === methodArg;
-      });
+    typedHandler = this.handlerMap.findSync((handler) => {
+      return handler.method === methodArg;
+    });
 
-      if (!typedHandler) {
-        this.routerMap.getArray().forEach(typedRouter => {
-          if (!typedHandler) {
-            typedHandler = typedRouter.getTypedHandlerForMethod(methodArg, false);
-          }
-        });
-      }
+    if (!typedHandler) {
+      this.routerMap.getArray().forEach((typedRouterArg) => {
+        if (!typedHandler && !checkedRouters.includes(typedRouterArg)) {
+          typedHandler = typedRouterArg.getTypedHandlerForMethod(methodArg, checkedRouters);
+        }
+      });
     }
 
     return typedHandler;
   }
 
   /**
-   * routes a typed request to a handler
+   * if typedrequest object has correlation.phase === 'request' -> routes a typed request object to a handler
+   * if typedrequest object has correlation.phase === 'response' -> routes a typed request object to request fire event
    * @param typedRequestArg
    */
-  public async routeAndAddResponse(typedRequestArg: plugins.typedRequestInterfaces.ITypedRequest) {
-    const typedHandler = this.getTypedHandlerForMethod(typedRequestArg.method);
+  public async routeAndAddResponse<
+    T extends plugins.typedRequestInterfaces.ITypedRequest = plugins.typedRequestInterfaces.ITypedRequest
+  >(typedRequestArg: T, localRequestArg = false): Promise<T> {
+    // decoding first
+    typedRequestArg = VirtualStream.decodePayloadFromNetwork(typedRequestArg, {
+      typedrouter: this,
+    });
 
-    if (!typedHandler) {
-      const availableMethods: string[] = [];
-      await this.handlerMap.forEach(async handler => {
-        availableMethods.push(handler.method);
-      });
-      console.log(`Cannot find method for ${typedHandler}`);
-      console.log(`Available methods are:`);
-      console.log(availableMethods);
-      typedRequestArg.error = {
-        text: 'There is no available method for this call on the server side',
-        data: {}
-      };
-      return typedRequestArg;
+    // localdata second
+    typedRequestArg.localData = typedRequestArg.localData || {};
+    typedRequestArg.localData.firstTypedrouter = this;
+
+    // lets do stream processing
+    if (typedRequestArg.method === '##VirtualStream##') {
+      const result: any = await this.handleStreamTypedRequest(typedRequestArg as plugins.typedRequestInterfaces.IStreamRequest);
+      result.localData = null;
+      return result as T;
     }
 
-    typedRequestArg = await typedHandler.addResponse(typedRequestArg);
-    return typedRequestArg;
+    // lets do normal routing
+    if (typedRequestArg?.correlation?.phase === 'request' || localRequestArg) {
+      const typedHandler = this.getTypedHandlerForMethod(typedRequestArg.method);
+
+      if (!typedHandler) {
+        console.log(`Cannot find handler for methodname ${typedRequestArg.method}`);
+        typedRequestArg.error = {
+          text: 'There is no available method for this call on the server side',
+          data: {},
+        };
+        typedRequestArg.correlation.phase = 'response';
+
+        // encode again before handing back
+        typedRequestArg = VirtualStream.encodePayloadForNetwork(typedRequestArg, {
+          typedrouter: this,
+        });
+        return typedRequestArg;
+      }
+
+      typedRequestArg = await typedHandler.addResponse(typedRequestArg);
+      typedRequestArg.localData = null;
+      // encode again before handing back
+      typedRequestArg = VirtualStream.encodePayloadForNetwork(typedRequestArg, {
+        typedrouter: this,
+      });
+      return typedRequestArg;
+    } else if (typedRequestArg?.correlation?.phase === 'response') {
+      this.fireEventInterestMap
+        .findInterest(typedRequestArg.correlation.id)
+        ?.fullfillInterest(typedRequestArg);
+      return null;
+    } else {
+      console.log('received weirdly shaped request');
+      console.log(typedRequestArg);
+      return null;
+    }
+  }
+
+  /**
+   * handle streaming
+   * @param streamTrArg 
+   */
+  public async handleStreamTypedRequest(streamTrArg: plugins.typedRequestInterfaces.IStreamRequest) {
+    const relevantVirtualStream = await this.registeredVirtualStreams.find(async virtualStreamArg => {
+      return virtualStreamArg.streamId === streamTrArg.request.streamId;
+    });
+    if (!relevantVirtualStream) {
+      console.log(`no relevant virtual stream found for stream with id ${streamTrArg.request.streamId}`);
+      console.log(this.registeredVirtualStreams.getArray());
+      return streamTrArg;
+    } else {
+      console.log(`success: found relevant virtual stream with id ${streamTrArg.request.streamId}`);
+    }
+    const result = await relevantVirtualStream.handleStreamTr(streamTrArg);
+    return result;
   }
 }

ts/typedrequest.classes.typedtarget.ts

@@ -0,0 +1,81 @@
+import { TypedRouter } from './typedrequest.classes.typedrouter.js';
+import * as plugins from './plugins.js';
+
+export type IPostMethod = (
+  typedRequestPostObject: plugins.typedRequestInterfaces.ITypedRequest
+) => Promise<plugins.typedRequestInterfaces.ITypedRequest>;
+
+/**
+ * this is an alternative to a post url supplied in `new Typedrequest(new TypedTarget(...), 'someMethodName')`
+ * enables the use of custom post functions
+ * used for things like broadcast channels
+ * e.g. @designestate/dees-comms
+ * the main difference here is, that the response comes back async and is routed by interest through typedrouter
+ */
+export type IPostMethodWithTypedRouter = (
+  typedRequestPostObject: plugins.typedRequestInterfaces.ITypedRequest
+) => Promise<void> | Promise<plugins.typedRequestInterfaces.ITypedRequest>;
+
+export interface ITypedTargetConstructorOptions {
+  url?: string;
+  postMethod?: IPostMethod;
+  /**
+   * a post method that does not return the answer
+   */
+  postMethodWithTypedRouter?: IPostMethodWithTypedRouter;
+  /**
+   * this typedrouter allows us to have easy async request response cycles
+   */
+  typedRouterRef?: TypedRouter;
+}
+
+/**
+ * a typed target defines a target for requests
+ */
+export class TypedTarget {
+  url: string;
+  type: 'rest' | 'socket';
+  options: ITypedTargetConstructorOptions;
+
+  constructor(optionsArg: ITypedTargetConstructorOptions) {
+    if (optionsArg.postMethodWithTypedRouter && !optionsArg.typedRouterRef) {
+      throw new Error('you have to specify a typedrouter when using postmethod with typedrouter');
+    }
+    this.options = optionsArg;
+  }
+
+  /**
+   * wether calls to this target are bound to the request/response cycle
+   * if false, always delivers response as result of a call
+   * if true, delivers response in a separate call
+   * can only be async when type is 'socket'
+   */
+  public isAsync: boolean;
+
+  public async post<T extends plugins.typedRequestInterfaces.ITypedRequest>(
+    payloadArg: T
+  ): Promise<T> {
+    let responseInterest: plugins.lik.Interest<
+      string,
+      plugins.typedRequestInterfaces.ITypedRequest
+    >;
+    // having a typedrouter allows us to work with async request response cycles.
+    if (this.options.typedRouterRef) {
+      responseInterest = await this.options.typedRouterRef.fireEventInterestMap.addInterest(
+        payloadArg.correlation.id,
+        payloadArg
+      );
+    }
+    const postMethod = this.options.postMethod || this.options.postMethodWithTypedRouter;
+    const postMethodReturnValue = await postMethod(payloadArg);
+    let responseBody: T;
+    if (responseInterest) {
+      responseBody = (await responseInterest.interestFullfilled) as T;
+    } else if (postMethodReturnValue) {
+      responseBody = postMethodReturnValue as T;
+    } else {
+      responseBody = payloadArg;
+    }
+    return responseBody;
+  }
+}

ts/typedrequest.classes.virtualstream.ts

@@ -0,0 +1,376 @@
+import * as plugins from './plugins.js';
+import type { TypedRouter } from './typedrequest.classes.typedrouter.js';
+
+export interface ICommFunctions {
+  sendMethod?: (
+    sendPayload: plugins.typedRequestInterfaces.IStreamRequest
+  ) => Promise<plugins.typedRequestInterfaces.IStreamRequest>;
+  typedrouter?: TypedRouter;
+}
+
+/**
+ * 1. A VirtualStream connects over the network
+ * 2. It is always paired to one other VirtualStream
+ *    on the other side with the same streamId.
+ * 3. It has a Readable and Writable side.
+ * 4. The Writable side is Readable on the other side and vice versa.
+ */
+export class VirtualStream<T = ArrayBufferLike> implements plugins.typedRequestInterfaces.IVirtualStream<T> {
+  // STATIC
+  public static encodePayloadForNetwork(
+    objectPayload: any,
+    commFunctions: ICommFunctions,
+    originalPayload?: any,
+    path = []
+  ): any {
+    if (!objectPayload) {
+      return objectPayload;
+    }
+    if (plugins.smartbuffer.isBufferLike(objectPayload)) {
+      return objectPayload;
+    }
+    if (objectPayload instanceof VirtualStream) {
+      if (!objectPayload.side && commFunctions.sendMethod) {
+        objectPayload.side = 'requesting';
+        objectPayload.sendMethod = commFunctions.sendMethod;
+      }
+      if (!objectPayload.side && commFunctions.typedrouter) {
+        objectPayload.side = 'responding';
+        objectPayload.typedrouter = commFunctions.typedrouter;
+        commFunctions.typedrouter.registeredVirtualStreams.add(objectPayload);
+      }
+      if (!originalPayload.response || path.includes('response')) {
+        objectPayload.startKeepAliveLoop();
+        return {
+          _isVirtualStream: true,
+          streamId: objectPayload.streamId,
+        };
+      } else {
+        return {
+          _OBMITTED_VIRTUAL_STREAM: true,
+          reason: 'path is under .request: obmitted for deduplication reasons in response cycle.',
+        };
+      }
+    } else if (Array.isArray(objectPayload)) {
+      // For arrays, we recurse over each item.
+      return objectPayload.map((item, index) => 
+        VirtualStream.encodePayloadForNetwork(
+          item,
+          commFunctions,
+          originalPayload || objectPayload,
+          path.concat(String(index)) // Convert index to string and concatenate to path
+        )
+      );
+    } else if (objectPayload !== null && typeof objectPayload === 'object') {
+      // For objects, we recurse over each key-value pair.
+      return Object.entries(objectPayload).reduce((acc, [key, value]) => {
+        const newPath = path.concat(key); // Concatenate the new key to the path
+        acc[key] = VirtualStream.encodePayloadForNetwork(
+          value,
+          commFunctions,
+          originalPayload || objectPayload,
+          newPath
+        );
+        return acc;
+      }, {});
+    } else {
+      return objectPayload;
+    }
+  }
+
+  public static decodePayloadFromNetwork(objectPayload: any, commFunctions: ICommFunctions): any {
+    if (plugins.smartbuffer.isBufferLike(objectPayload)) {
+      return objectPayload;
+    }
+    if (objectPayload !== null && typeof objectPayload === 'object') {
+      if (objectPayload._isVirtualStream) {
+        const virtualStream = new VirtualStream();
+        virtualStream.streamId = objectPayload.streamId;
+        if (!virtualStream.side && commFunctions.sendMethod) {
+          virtualStream.side = 'requesting';
+          virtualStream.sendMethod = commFunctions.sendMethod;
+        }
+        if (!virtualStream.side && commFunctions.typedrouter) {
+          virtualStream.side = 'responding';
+          virtualStream.typedrouter = commFunctions.typedrouter;
+          commFunctions.typedrouter.registeredVirtualStreams.add(virtualStream);
+        }
+        virtualStream.startKeepAliveLoop();
+        return virtualStream;
+      } else if (Array.isArray(objectPayload)) {
+        const returnArray = [];
+        for (const item of objectPayload) {
+          returnArray.push(VirtualStream.decodePayloadFromNetwork(item, commFunctions));
+        }
+        return returnArray;
+      } else {
+        return Object.keys(objectPayload).reduce((acc, key) => {
+          acc[key] = VirtualStream.decodePayloadFromNetwork(objectPayload[key], commFunctions);
+          return acc;
+        }, {});
+      }
+    } else {
+      return objectPayload;
+    }
+  }
+
+  // INSTANCE
+
+  public side: 'requesting' | 'responding';
+  public streamId: string = plugins.isounique.uni();
+
+  // integration with typedrequest mechanics
+  public sendMethod: ICommFunctions['sendMethod'];
+  public typedrouter: TypedRouter;
+
+  // wether to keep the stream alive
+  private keepAlive = true;
+  private lastKeepAliveEvent: number;
+
+  // backpressured arrays
+  private sendBackpressuredArray =
+    new plugins.lik.BackpressuredArray<T>(
+      16
+    );
+  private receiveBackpressuredArray =
+    new plugins.lik.BackpressuredArray<T>(
+      16
+    );
+
+  constructor() {}
+
+  /**
+   * takes care of sending 
+   */
+  private async workOnQueue() {
+    if(this.side === 'requesting') {
+      let thisSideIsBackpressured = !this.receiveBackpressuredArray.checkSpaceAvailable();
+      let otherSideHasNext = false;
+      let otherSideIsBackpressured = false;
+      
+      // helper functions
+      const getFeedback = async () => {
+        const streamTr = await this.sendMethod({
+          method: '##VirtualStream##',
+          request: {
+            streamId: this.streamId,
+            cycleId: plugins.isounique.uni(),
+            cycle: 'request',
+            mainPurpose: 'feedback',
+            next: this.sendBackpressuredArray.data.length > 0,
+            backpressure: this.receiveBackpressuredArray.checkSpaceAvailable(),
+          },
+          response: null,
+        }).catch(() => {
+          console.log('stream ended immaturely');
+          this.keepAlive = false;
+        });
+        if (streamTr && streamTr.response) {
+          otherSideIsBackpressured = streamTr.response.backpressure
+          otherSideHasNext = streamTr.response.next;
+        }
+      }
+      await getFeedback();
+
+      // do work loop
+      while (this.sendBackpressuredArray.data.length > 0 || otherSideHasNext) {
+        let dataArg: typeof this.sendBackpressuredArray.data[0];
+        if (this.sendBackpressuredArray.data.length > 0) {
+          dataArg = this.sendBackpressuredArray.shift();
+        }
+        let streamTr: plugins.typedRequestInterfaces.IStreamRequest;
+        streamTr = await this.sendMethod({
+          method: '##VirtualStream##',
+          request: {
+            streamId: this.streamId,
+            cycleId: plugins.isounique.uni(),
+            cycle: 'request',
+            mainPurpose: dataArg ? 'chunk' : 'read',
+            backpressure: thisSideIsBackpressured,
+            next: this.sendBackpressuredArray.data.length > 0,
+            ...dataArg ? { chunkData: dataArg } : {},
+          },
+          response: null,
+        }).catch(() => {
+          console.log('stream ended immaturely');
+          this.keepAlive = false;
+          return null;
+        });
+
+        if (streamTr && streamTr.response && streamTr.response.chunkData) {
+          this.receiveBackpressuredArray.push(streamTr.response.chunkData);
+        }
+        thisSideIsBackpressured = this.receiveBackpressuredArray.checkSpaceAvailable();
+
+        // lets care about looping
+        otherSideHasNext = streamTr && streamTr.response && streamTr.response.next;
+      }
+
+    }
+  }
+
+  /**
+   * This method handles the stream only on the responding side
+   * @param streamTrArg
+   * @returns
+   */
+  public async handleStreamTr(streamTrArg: plugins.typedRequestInterfaces.IStreamRequest) {
+    if (streamTrArg.request.keepAlive === true && this.keepAlive === true) {
+      this.lastKeepAliveEvent = Date.now();
+    } else if (streamTrArg.request.keepAlive === false) {
+      this.keepAlive = false;
+    }
+
+    // keepAlive handling
+    if (streamTrArg.request.mainPurpose === 'keepAlive') {
+      // if the main purpose is keepAlive, we answer with a keepAlive
+      streamTrArg.response = {
+        streamId: this.streamId,
+        cycleId: streamTrArg.request.cycleId,
+        cycle: 'response',
+        mainPurpose: 'keepAlive',
+        keepAlive: this.keepAlive,
+        next: this.sendBackpressuredArray.data.length > 0,
+        backpressure: this.receiveBackpressuredArray.checkSpaceAvailable(),
+      };
+    }
+
+    // feedback handling
+    if (streamTrArg.request.mainPurpose === 'feedback') {
+      streamTrArg.response = {
+        streamId: this.streamId,
+        cycleId: streamTrArg.request.cycleId,
+        cycle: 'response',
+        mainPurpose: 'feedback',
+        next: this.sendBackpressuredArray.data.length > 0,
+        backpressure: this.receiveBackpressuredArray.checkSpaceAvailable(),
+      };
+    }
+
+    // chunk handling
+    if (streamTrArg.request.mainPurpose === 'chunk') {
+      this.receiveBackpressuredArray.push(streamTrArg.request.chunkData);
+      if (this.sendBackpressuredArray.data.length > 0 && streamTrArg.response.backpressure === false) {
+        const dataArg = this.sendBackpressuredArray.shift();
+        streamTrArg.response = {
+          streamId: this.streamId,
+          cycleId: streamTrArg.request.cycleId,
+          cycle: 'response',
+          mainPurpose: 'chunk',
+          next: this.sendBackpressuredArray.data.length > 1,
+          backpressure: this.receiveBackpressuredArray.checkSpaceAvailable(),
+          chunkData: this.sendBackpressuredArray.shift(),
+        };
+      } else {
+        streamTrArg.response = {
+          streamId: this.streamId,
+          cycleId: streamTrArg.request.cycleId,
+          cycle: 'response',
+          mainPurpose: 'feedback',
+          next: this.sendBackpressuredArray.data.length > 0,
+        };
+      }
+      streamTrArg.request = null;
+    }
+
+    return streamTrArg;
+  }
+
+  // lifecycle methods
+  /**
+   * closes the virtual stream
+   */
+  public async cleanup() {
+    if (this.typedrouter) {
+      this.typedrouter.registeredVirtualStreams.remove(this);
+    }
+  }
+
+  /**
+   * a keepAlive loop that works across technologies
+   */
+  private async startKeepAliveLoop() {
+    // initially wait for a second
+    await plugins.smartdelay.delayFor(0);
+    let counter = 0;
+    keepAliveLoop: while (this.keepAlive) {
+      const triggerResult = await this.triggerKeepAlive();
+      await plugins.smartdelay.delayFor(1000);
+    }
+    await plugins.smartdelay.delayFor(1000);
+    await this.cleanup();
+    console.log(`cleaned up for stream ${this.streamId}`);
+  }
+
+  private async triggerKeepAlive() {
+    if (this.side === 'requesting') {
+      console.log(`keepalive sent.`);
+      const streamTr = await this.sendMethod({
+        method: '##VirtualStream##',
+        request: {
+          streamId: this.streamId,
+          cycleId: plugins.isounique.uni(),
+          cycle: 'request',
+          mainPurpose: 'keepAlive',
+          keepAlive: true,
+        },
+        response: null,
+      }).catch(() => {
+        this.keepAlive = false;
+      });
+
+      // lets handle keepAlive
+      if (streamTr && streamTr.response && streamTr.response.keepAlive === false) {
+        this.keepAlive = false;
+      } else {
+        this.lastKeepAliveEvent = Date.now();
+      }
+      if (streamTr && streamTr.response && streamTr.response.next) {
+        this.workOnQueue();
+      }
+    }
+    if (Date.now() - this.lastKeepAliveEvent > 10000) {
+      console.log(`closing stream for ${this.streamId}`);
+      this.keepAlive = false;
+    }
+  }
+  
+  // Data sending and receiving
+  public async sendData(dataArg: T): Promise<void> {
+    this.sendBackpressuredArray.push(dataArg);
+    this.workOnQueue();
+    await this.sendBackpressuredArray.waitForSpace();
+  }
+
+  public async fetchData(): Promise<T> {
+    if (this.receiveBackpressuredArray.hasSpace) {
+      // do something maybe?
+    }
+    await this.receiveBackpressuredArray.waitForItems();
+    const dataPackage = this.receiveBackpressuredArray.shift();
+    return dataPackage;
+  }
+
+  /**
+   * reads from a Readable and sends it to the other side
+   * @param readableStreamArg
+   */
+  public async readFromWebstream(readableStreamArg: ReadableStream<T>) {
+    const reader = readableStreamArg.getReader();
+    let streamIsDone = false;
+    while(!streamIsDone) {
+      const { value, done } = await reader.read();
+      if(value) {
+        await this.sendData(value);
+      }
+      streamIsDone = done;
+    }
+  }
+
+  public async writeToWebstream(writableStreamArg: WritableStream<T>) {
+    const writer = writableStreamArg.getWriter();
+    while(this.keepAlive) {
+      await writer.write(await this.fetchData());
+    }
+  }
+}

ts/typedrequest.plugins.ts

@@ -1,12 +0,0 @@
-// apiglobal scope
-import * as typedRequestInterfaces from '@apiglobal/typedrequest-interfaces';
-
-export { typedRequestInterfaces };
-
-// pushrocks scope
-import * as lik from '@pushrocks/lik';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartrequest from '@pushrocks/smartrequest';
-import * as smartjson from '@pushrocks/smartjson';
-
-export { lik, smartdelay, smartrequest, smartjson };

tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}