3.0.1

.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,34 +1,35 @@
 {
-  "name": "@apiglobal/typedrequest",
-  "version": "1.0.41",
+  "name": "@api.global/typedrequest",
+  "version": "3.0.1",
   "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 && tsbundle npm)",
-    "format": "(gitzone format)"
+    "build": "(tsbuild --web --allowimplicitany && tsbundle npm)",
+    "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.24",
-    "@gitzone/tsbundle": "^1.0.72",
-    "@gitzone/tstest": "^1.0.43",
-    "@pushrocks/smartexpress": "^3.0.73",
-    "@pushrocks/tapbundle": "^3.2.9",
-    "@types/node": "^14.0.26",
-    "tslint": "^6.1.2",
-    "tslint-config-prettier": "^1.18.0"
+    "@api.global/typedserver": "^3.0.1",
+    "@gitzone/tsbuild": "^2.1.66",
+    "@gitzone/tsbundle": "^2.0.8",
+    "@gitzone/tsrun": "^1.2.44",
+    "@gitzone/tstest": "^1.0.77",
+    "@push.rocks/smartenv": "^5.0.3",
+    "@push.rocks/tapbundle": "^5.0.12",
+    "@types/node": "^20.4.7"
   },
   "dependencies": {
-    "@apiglobal/typedrequest-interfaces": "^1.0.15",
-    "@pushrocks/isounique": "^1.0.4",
-    "@pushrocks/lik": "^4.0.17",
-    "@pushrocks/smartdelay": "^2.0.10",
-    "@pushrocks/smartpromise": "^3.0.6",
-    "@pushrocks/webrequest": "^2.0.10"
+    "@api.global/typedrequest-interfaces": "^3.0.1",
+    "@push.rocks/isounique": "^1.0.5",
+    "@push.rocks/lik": "^6.0.3",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/webrequest": "^3.0.32"
   },
   "files": [
     "ts/**/*",
@@ -41,5 +42,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/test.browser.ts

@@ -0,0 +1,39 @@
+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/testroute',
+    'hi'
+  );
+});
+
+tap.start();

test/test.ts

@@ -1,11 +1,12 @@
-import { expect, tap } from '@pushrocks/tapbundle';
-import * as smartexpress from '@pushrocks/smartexpress';
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as typedserver from '@api.global/typedserver';
 
-import * as typedrequest from '../ts/index';
+import * as typedrequest from '../ts/index.js';
 
-let testServer: smartexpress.Server;
+let testServer: typedserver.servertools.Server;
 let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
 
+// lets define an interface
 interface ITestReqRes {
   method: 'hi';
   request: {
@@ -17,27 +18,28 @@ interface ITestReqRes {
 }
 
 tap.test('should create a typedHandler', async () => {
-  testTypedHandler = new typedrequest.TypedHandler<ITestReqRes>('hi', async reqArg => {
+  // lets use the interface in a TypedHandler
+  testTypedHandler = new typedrequest.TypedHandler<ITestReqRes>('hi', async (reqArg) => {
     return {
-      surname: 'wow'
+      surname: 'wow',
     };
   });
 });
 
 tap.test('should spawn a server to test with', async () => {
-  testServer = new smartexpress.Server({
+  testServer = new typedserver.servertools.Server({
     cors: true,
     forceSsl: false,
-    port: 3000
+    port: 3000,
   });
 });
 
 tap.test('should define a testHandler', async () => {
-  const testTypedRouter = new typedrequest.TypedRouter();
+  const testTypedRouter = new typedrequest.TypedRouter(); // typed routers can broker typedrequests between handlers
   testTypedRouter.addTypedHandler(testTypedHandler);
   testServer.addRoute(
     '/testroute',
-    new smartexpress.HandlerTypedRouter(testTypedRouter as any)
+    new typedserver.servertools.HandlerTypedRouter(testTypedRouter as any) // the "any" is testspecific, since smartexpress ships with its own version of typedrequest.
   );
 });
 
@@ -51,11 +53,11 @@ tap.test('should fire a request', async () => {
     'hi'
   );
   const response = await typedRequest.fire({
-    name: 'really'
+    name: 'really',
   });
   console.log('this is the response:');
   console.log(response);
-  expect(response.surname).to.equal('wow');
+  expect(response.surname).toEqual('wow');
 });
 
 tap.test('should end the server', async () => {

ts/00_commitinfo_data.ts

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

ts/index.ts

@@ -1,4 +1,5 @@
-export * from './typedrequest.classes.typedrequest';
-export * from './typedrequest.classes.typedhandler';
-export * from './typedrequest.classes.typedrouter';
-export * from './typedrequest.classes.typedresponseerror';
+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';

ts/typedrequest.classes.typedhandler.ts

@@ -1,7 +1,7 @@
-import * as plugins from './typedrequest.plugins';
-import { TypedResponseError } from './typedrequest.classes.typedresponseerror';
+import * as plugins from './typedrequest.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']>;
 
@@ -28,18 +28,18 @@ export class TypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest
       );
     }
     let typedResponseError: TypedResponseError;
-    const response = await this.handlerFunction(typedRequestArg.request).catch(e => {
+    const response = await this.handlerFunction(typedRequestArg.request).catch((e) => {
       if (e instanceof TypedResponseError) {
         typedResponseError = e;
       } else {
-        throw e;
+        console.log(e);
       }
     });
 
     if (typedResponseError) {
       typedRequestArg.error = {
         text: typedResponseError.errorText,
-        data: typedResponseError.errorData
+        data: typedResponseError.errorData,
       };
     }
 
@@ -47,7 +47,7 @@ export class TypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest
       typedRequestArg.response = response;
     }
 
-    typedRequestArg.correlation.phase = 'response';
+    typedRequestArg?.correlation?.phase ? (typedRequestArg.correlation.phase = 'response') : null;
 
     return typedRequestArg;
   }

ts/typedrequest.classes.typedrequest.ts

@@ -1,45 +1,41 @@
-import * as plugins from './typedrequest.plugins';
-import { TypedResponseError } from './typedrequest.classes.typedresponseerror';
-import { TypedRouter } from './typedrequest.classes.typedrouter';
+import * as plugins from './typedrequest.plugins.js';
+import { TypedResponseError } from './typedrequest.classes.typedresponseerror.js';
+import { TypedRouter } from './typedrequest.classes.typedrouter.js';
+import { TypedTarget } from './typedrequest.classes.typedtarget.js';
 
-export type IPostMethod = (
-  typedRequestPostObject: plugins.typedRequestInterfaces.ITypedRequest
-) => void | Promise<plugins.typedRequestInterfaces.ITypedRequest>;
+const webrequestInstance = new plugins.webrequest.WebRequest();
 
 export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest> {
-  public typedRouterRef: TypedRouter;
-  public webrequest = new plugins.webrequest.WebRequest();
-
   /**
    * in case we post against a url endpoint
    */
   public urlEndPoint?: string;
 
   /**
-   * in case we post with some other method, ec ipc communication
+   * in case we post against a TypedTarget
    */
-  public postMethod?: IPostMethod;
+  typedTarget: TypedTarget;
+
   public method: string;
 
-  // STATIC
-  constructor(
-    postEndPointArg: string | IPostMethod,
-    methodArg: T['method'],
-    typedrouterRefArg?: TypedRouter
-  ) {
-    if (typeof postEndPointArg === 'string') {
-      this.urlEndPoint = postEndPointArg;
+  /**
+   * note the overloading is thought to deal with promises
+   * @param postEndPointArg
+   * @param methodArg
+   */
+  constructor(postTarget: string | TypedTarget, methodArg: T['method']) {
+    if (typeof postTarget === 'string') {
+      this.urlEndPoint = postTarget;
     } else {
-      this.postMethod = postEndPointArg;
+      this.typedTarget = postTarget;
     }
     this.method = methodArg;
-    this.typedRouterRef = typedrouterRefArg;
   }
 
   /**
    * fires the request
    */
-  public async fire(fireArg: T['request']): Promise<T['response']> {
+  public async fire(fireArg: T['request'], useCacheArg: boolean = false): Promise<T['response']> {
     const payload: plugins.typedRequestInterfaces.ITypedRequest = {
       method: this.method,
       request: fireArg,
@@ -52,27 +48,10 @@ export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest
 
     let responseBody: plugins.typedRequestInterfaces.ITypedRequest;
     if (this.urlEndPoint) {
-      const response = await this.webrequest.postJson(this.urlEndPoint, payload);
+      const response = await webrequestInstance.postJson(this.urlEndPoint, payload, useCacheArg);
       responseBody = response;
     } else {
-      let responseInterest: plugins.lik.Interest<
-          string,
-          plugins.typedRequestInterfaces.ITypedRequest
-      >;
-      if (this.typedRouterRef) {
-        responseInterest = await this.typedRouterRef.fireEventInterestMap.addInterest(
-          payload.correlation.id,
-          payload
-        );
-      }
-      const postMethodReturnValue = await this.postMethod(payload);
-      if (responseInterest) {
-        responseBody = await responseInterest.interestFullfilled;
-      } else if (postMethodReturnValue) {
-        responseBody = postMethodReturnValue;
-      } else {
-        responseBody = payload;
-      }
+      responseBody = await this.typedTarget.post(payload);
     }
     if (responseBody.error) {
       console.error(

ts/typedrequest.classes.typedresponseerror.ts

@@ -1,4 +1,4 @@
-import * as plugins from './typedrequest.plugins';
+import * as plugins from './typedrequest.plugins.js';
 
 export class TypedResponseError {
   public errorText: string;

ts/typedrequest.classes.typedrouter.ts

@@ -1,7 +1,7 @@
-import * as plugins from './typedrequest.plugins';
+import * as plugins from './typedrequest.plugins.js';
 
-import { TypedHandler } from './typedrequest.classes.typedhandler';
-import { TypedRequest } from './typedrequest.classes.typedrequest';
+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
@@ -9,12 +9,9 @@ import { TypedRequest } from './typedrequest.classes.typedrequest';
  * 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 fireEventInterestMap = new plugins.lik.InterestMap<
@@ -45,11 +42,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 {
@@ -63,24 +60,22 @@ 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;
@@ -91,8 +86,10 @@ export class TypedRouter {
    * 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) {
-    if (typedRequestArg.correlation.phase === 'request') {
+  public async routeAndAddResponse<
+    T extends plugins.typedRequestInterfaces.ITypedRequest = plugins.typedRequestInterfaces.ITypedRequest
+  >(typedRequestArg: T, localRequestArg = false): Promise<T> {
+    if (typedRequestArg?.correlation?.phase === 'request' || localRequestArg) {
       const typedHandler = this.getTypedHandlerForMethod(typedRequestArg.method);
 
       if (!typedHandler) {
@@ -101,15 +98,21 @@ export class TypedRouter {
           text: 'There is no available method for this call on the server side',
           data: {},
         };
+        typedRequestArg.correlation.phase = 'response';
         return typedRequestArg;
       }
 
       typedRequestArg = await typedHandler.addResponse(typedRequestArg);
-    } else if (typedRequestArg.correlation.phase === 'response') {
+      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;
     }
-    return typedRequestArg;
   }
 }

ts/typedrequest.classes.typedtarget.ts

@@ -0,0 +1,81 @@
+import { TypedRouter } from './typedrequest.classes.typedrouter.js';
+import * as plugins from './typedrequest.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.plugins.ts

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

tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true
+  }
+}

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"
-}