1.0.39

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apiglobal/typedrequest",
-  "version": "1.0.31",
+  "version": "1.0.39",
   "private": false,
   "description": "make typed requests towards apis",
   "main": "dist_ts/index.js",
@@ -9,24 +9,25 @@
   "license": "MIT",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild --web)",
+    "build": "(tsbuild --web && tsbundle npm)",
     "format": "(gitzone format)"
   },
   "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",
+    "@gitzone/tsbundle": "^1.0.72",
+    "@gitzone/tstest": "^1.0.43",
+    "@pushrocks/smartexpress": "^3.0.73",
+    "@pushrocks/tapbundle": "^3.2.9",
+    "@types/node": "^14.0.23",
     "tslint": "^6.1.2",
     "tslint-config-prettier": "^1.18.0"
   },
   "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"
+    "@apiglobal/typedrequest-interfaces": "^1.0.15",
+    "@pushrocks/isounique": "^1.0.4",
+    "@pushrocks/lik": "^4.0.14",
+    "@pushrocks/smartdelay": "^2.0.10",
+    "@pushrocks/webrequest": "^2.0.10"
   },
   "files": [
     "ts/**/*",

test/test.ts

@@ -54,6 +54,7 @@ tap.test('should fire a request', async () => {
   const response = await typedRequest.fire({
     name: 'really'
   });
+  console.log('this is the response:');
   console.log(response);
   expect(response.surname).to.equal('wow');
 });

ts/index.ts

@@ -1,3 +1,4 @@
 export * from './typedrequest.classes.typedrequest';
 export * from './typedrequest.classes.typedhandler';
 export * from './typedrequest.classes.typedrouter';
+export * from './typedrequest.classes.typedresponseerror';

ts/typedrequest.classes.typedhandler.ts

@@ -1,4 +1,5 @@
 import * as plugins from './typedrequest.plugins';
+import { TypedResponseError } from './typedrequest.classes.typedresponseerror';
 
 type THandlerFunction<T extends plugins.typedRequestInterfaces.ITypedRequest> = (
   requestArg: T['request']
@@ -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 {
+        throw e;
+      }
+    });
+
+    if (typedResponseError) {
+      typedRequestArg.error = {
+        text: typedResponseError.errorText,
+        data: typedResponseError.errorData
+      };
+    }
+
+    if (response) {
+      typedRequestArg.response = response;
+    }
+
+    typedRequestArg.correlation.phase = 'response';
+
     return typedRequestArg;
   }
 }

ts/typedrequest.classes.typedrequest.ts

@@ -1,6 +1,10 @@
 import * as plugins from './typedrequest.plugins';
+import { TypedResponseError } from './typedrequest.classes.typedresponseerror';
+import { TypedRouter } from './typedrequest.classes.typedrouter';
 
 export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest> {
+  public typedRouterRef: TypedRouter;
+  public webrequest = new plugins.webrequest.WebRequest();
   public urlEndPoint: string;
   public method: string;
 
@@ -11,20 +15,30 @@ export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest
   }
 
   /**
-   * 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
+    const payload: plugins.typedRequestInterfaces.ITypedRequest = {
+      method: this.method,
+      request: fireArg,
+      response: null,
+      correlation: {
+        id: plugins.isounique.uni(),
+        phase: 'request'
       }
-    });
-    const responseBody: T = response.body;
+    };
+
+    const response = await this.webrequest.postJson(this.urlEndPoint, payload);
+    const responseBody: T = response;
     if (responseBody.error) {
-      console.log(responseBody.error.text);
-      console.log(responseBody.error.data);
+      console.error(
+        `Got an error ${responseBody.error.text} with data ${JSON.stringify(
+          responseBody.error.data
+        )}`
+      );
+      if (!responseBody.retry) {
+        throw new TypedResponseError(responseBody.error.text, responseBody.error.data);
+      }
       return null;
     }
     if (responseBody.retry) {
@@ -35,4 +49,13 @@ export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest
     }
     return responseBody.response;
   }
+
+  public addTypedRouterForResponse(typedRouterArg: TypedRouter) {
+    if (!this.typedRouterRef) {
+      this.typedRouterRef = typedRouterArg;
+      typedRouterArg.addTypedRequest(this);
+    }
+  }
+
+  public registerAlternateFireMethod() {}
 }

ts/typedrequest.classes.typedresponseerror.ts

@@ -0,0 +1,10 @@
+import * as plugins from './typedrequest.plugins';
+
+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,7 @@
 import * as plugins from './typedrequest.plugins';
 
 import { TypedHandler } from './typedrequest.classes.typedhandler';
+import { TypedRequest } from './typedrequest.classes.typedrequest';
 
 /**
  * A typed router decides on which typed handler to call based on the method
@@ -11,11 +12,22 @@ export class TypedRouter {
   public upstreamTypedRouter: TypedRouter;
 
   public routerMap = new plugins.lik.ObjectMap<TypedRouter>();
+  public typedRequestMap = new plugins.lik.ObjectMap<TypedRequest<any>>();
 
   public handlerMap = new plugins.lik.ObjectMap<
     TypedHandler<plugins.typedRequestInterfaces.ITypedRequest>
   >();
 
+  public fireEventInterestMap = new plugins.lik.InterestMap((correlationId: string) => correlationId);
+
+  public addTypedRequest(typedRequestArg: TypedRequest<any>) {
+    if(!this.typedRequestMap.checkForObject(typedRequestArg)) {
+      this.typedRequestMap.add(typedRequestArg);
+      typedRequestArg.addTypedRouterForResponse(this);
+    }
+  }
+
+
   /**
    * adds the handler to the routing map
    * @param typedHandlerArg
@@ -64,12 +76,12 @@ export class TypedRouter {
     if (this.upstreamTypedRouter && checkUpstreamRouter) {
       typedHandler = this.upstreamTypedRouter.getTypedHandlerForMethod(methodArg);
     } else {
-      typedHandler = this.handlerMap.find(handler => {
+      typedHandler = this.handlerMap.find((handler) => {
         return handler.method === methodArg;
       });
 
       if (!typedHandler) {
-        this.routerMap.getArray().forEach(typedRouter => {
+        this.routerMap.getArray().forEach((typedRouter) => {
           if (!typedHandler) {
             typedHandler = typedRouter.getTypedHandlerForMethod(methodArg, false);
           }
@@ -81,28 +93,27 @@ export class TypedRouter {
   }
 
   /**
-   * 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);
+    if (typedRequestArg.correlation.phase === 'request') {
+      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: {},
+        };
+        return typedRequestArg;
+      }
+
+      typedRequestArg = await typedHandler.addResponse(typedRequestArg);
+    } else if (typedRequestArg.correlation.phase === 'response') {
 
-    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;
     }
-
-    typedRequestArg = await typedHandler.addResponse(typedRequestArg);
     return typedRequestArg;
   }
 }

ts/typedrequest.plugins.ts

@@ -4,9 +4,9 @@ import * as typedRequestInterfaces from '@apiglobal/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 smartrequest from '@pushrocks/smartrequest';
-import * as smartjson from '@pushrocks/smartjson';
+import * as webrequest from '@pushrocks/webrequest';
 
-export { lik, smartdelay, smartrequest, smartjson };
+export { isounique, lik, smartdelay, webrequest };