2.0.8

package.json

@@ -1,34 +1,34 @@
 {
   "name": "@apiglobal/typedrequest",
-  "version": "1.0.54",
+  "version": "2.0.8",
   "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)",
+    "build": "(tsbuild --web --allowimplicitany && tsbundle npm)",
     "format": "(gitzone format)"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tsbundle": "^1.0.78",
-    "@gitzone/tstest": "^1.0.52",
-    "@pushrocks/smartexpress": "^3.0.76",
-    "@pushrocks/tapbundle": "^3.2.9",
-    "@types/node": "^14.11.8",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0"
+    "@gitzone/tsbuild": "^2.1.63",
+    "@gitzone/tsbundle": "^2.0.6",
+    "@gitzone/tstest": "^1.0.72",
+    "@pushrocks/smartenv": "^5.0.2",
+    "@pushrocks/smartexpress": "^4.0.5",
+    "@pushrocks/tapbundle": "^5.0.4",
+    "@types/node": "^18.6.2"
   },
   "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.12"
+    "@pushrocks/isounique": "^1.0.5",
+    "@pushrocks/lik": "^6.0.0",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartpromise": "^3.1.7",
+    "@pushrocks/webrequest": "^3.0.9"
   },
   "files": [
     "ts/**/*",

test/test.browser.ts

@@ -1,6 +1,6 @@
 import { expect, tap } from '@pushrocks/tapbundle';
 
-import * as typedrequest from '../ts/index';
+import * as typedrequest from '../ts/index.js';
 
 let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
 

test/test.ts

@@ -1,7 +1,7 @@
 import { expect, tap } from '@pushrocks/tapbundle';
 import * as smartexpress from '@pushrocks/smartexpress';
 
-import * as typedrequest from '../ts/index';
+import * as typedrequest from '../ts/index.js';
 
 let testServer: smartexpress.Server;
 let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
@@ -57,7 +57,7 @@ tap.test('should fire a request', async () => {
   });
   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: '@apiglobal/typedrequest',
+  version: '2.0.8',
+  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,5 +1,5 @@
-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';
 
 export type THandlerFunction<T extends plugins.typedRequestInterfaces.ITypedRequest> = (
   requestArg: T['request']
@@ -32,7 +32,7 @@ export class TypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest
       if (e instanceof TypedResponseError) {
         typedResponseError = e;
       } else {
-        throw e;
+        console.log(e);
       }
     });
 

ts/typedrequest.classes.typedrequest.ts

@@ -1,21 +1,12 @@
-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
-) => Promise<plugins.typedRequestInterfaces.ITypedRequest>;
-
-export type IPostMethodWithTypedRouter = (
-  typedRequestPostObject: plugins.typedRequestInterfaces.ITypedRequest
-) => Promise<void> | Promise<plugins.typedRequestInterfaces.ITypedRequest>;
+const webrequestInstance = new plugins.webrequest.WebRequest();
 
 export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest> {
-  /**
-   * this typedrouter allows us to have easy async request response cycles
-   */
-  public typedRouterRef: TypedRouter;
-  public webrequest = new plugins.webrequest.WebRequest();
+
 
   /**
    * in case we post against a url endpoint
@@ -23,36 +14,30 @@ export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest
   public urlEndPoint?: string;
 
   /**
-   * in case we post with some other method, ec ipc communication
+   * in case we post against a TypedTarget
    */
-  public postMethod?: IPostMethod | IPostMethodWithTypedRouter;
+  typedTarget: TypedTarget;
+
   public method: string;
 
-  // STATIC
-  constructor(postEndPointArg: string | IPostMethod, methodArg: T['method']);
-  constructor(
-    postEndPointArg: string | IPostMethodWithTypedRouter,
-    methodArg: T['method'],
-    typedrouterRefArg: TypedRouter
-  );
-  constructor(
-    postEndPointArg: string | IPostMethodWithTypedRouter,
-    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,
@@ -65,28 +50,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
-      >;
-      // having a typedrouter allows us to work with async request response cycles.
-      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<
@@ -26,7 +23,7 @@ export class TypedRouter {
    * adds the handler to the routing map
    * @param typedHandlerArg
    */
-  public addTypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest>(
+  public addTypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest> (
     typedHandlerArg: TypedHandler<T>
   ) {
     // lets check for deduplication
@@ -44,15 +41,15 @@ export class TypedRouter {
    * adds another sub typedRouter
    * @param typedRequest
    */
-  public addTypedRouter(typedRouterArg: TypedRouter) {
-    this.routerMap.add(typedRouterArg);
+  public addTypedRouter (typedRouterArg: TypedRouter) {
+    const routerExists = this.routerMap.findSync(routerArg => routerArg === typedRouterArg)
+    if (!routerExists) {
+      this.routerMap.add(typedRouterArg);
+      typedRouterArg.addTypedRouter(this);
+    }
   }
 
-  public setUpstreamTypedRouter(typedRouterArg: TypedRouter) {
-    this.upstreamTypedRouter = typedRouterArg;
-  }
-
-  public checkForTypedHandler(methodArg: string): boolean {
+  public checkForTypedHandler (methodArg: string): boolean {
     return !!this.getTypedHandlerForMethod(methodArg);
   }
 
@@ -61,26 +58,24 @@ export class TypedRouter {
    * @param methodArg
    * @param checkUpstreamRouter
    */
-  public getTypedHandlerForMethod(
+  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,8 @@ 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 || typedRequestArg.correlation.phase === 'request') {
+  public async routeAndAddResponse<T extends plugins.typedRequestInterfaces.ITypedRequest = plugins.typedRequestInterfaces.ITypedRequest> (typedRequestArg: T): Promise<T> {
+    if (typedRequestArg?.correlation?.phase === 'request') {
       const typedHandler = this.getTypedHandlerForMethod(typedRequestArg.method);
 
       if (!typedHandler) {
@@ -101,24 +96,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 {}
+      return null
     }
-    return {
-      ...typedRequestArg,
-      ...{
-        method: 'nullPathFromResponse',
-      },
-    };
   }
 }

ts/typedrequest.classes.typedtarget.ts

@@ -0,0 +1,79 @@
+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;
+  }
+}

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