1.0.65

.gitlab-ci.yml

@@ -19,23 +19,35 @@ mirror:
   stage: security
   script:
     - npmci git mirror
+  only:
+    - tags
   tags:
     - lossless
     - docker
     - notpriv
 
-audit:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - 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:
+    - docker
+
+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 +62,7 @@ testStable:
     - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - priv
 
 testBuild:
   stage: test
@@ -63,9 +73,7 @@ testBuild:
     - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - notpriv
 
 release:
   stage: release
@@ -85,6 +93,8 @@ release:
 codequality:
   stage: metadata
   allow_failure: true
+  only:
+    - tags
   script:
     - npmci command npm install -g tslint typescript
     - npmci npm prepare

.vscode/settings.json

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apiglobal/typedrequest",
-  "version": "1.0.39",
+  "version": "1.0.65",
   "private": false,
   "description": "make typed requests towards apis",
   "main": "dist_ts/index.js",
@@ -13,21 +13,22 @@
     "format": "(gitzone format)"
   },
   "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.23",
-    "tslint": "^6.1.2",
+    "@gitzone/tsbuild": "^2.1.28",
+    "@gitzone/tsbundle": "^1.0.88",
+    "@gitzone/tstest": "^1.0.60",
+    "@pushrocks/smartexpress": "^3.0.108",
+    "@pushrocks/tapbundle": "^3.2.14",
+    "@types/node": "^16.11.6",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
     "@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"
+    "@pushrocks/lik": "^5.0.0",
+    "@pushrocks/smartdelay": "^2.0.13",
+    "@pushrocks/smartpromise": "^3.1.6",
+    "@pushrocks/webrequest": "^2.0.13"
   },
   "files": [
     "ts/**/*",
@@ -40,5 +41,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 '@pushrocks/tapbundle';
+
+import * as typedrequest from '../ts/index';
+
+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

@@ -6,6 +6,7 @@ import * as typedrequest from '../ts/index';
 let testServer: smartexpress.Server;
 let testTypedHandler: typedrequest.TypedHandler<ITestReqRes>;
 
+// lets define an interface
 interface ITestReqRes {
   method: 'hi';
   request: {
@@ -17,9 +18,10 @@ 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',
     };
   });
 });
@@ -28,17 +30,16 @@ tap.test('should spawn a server to test with', async () => {
   testServer = new smartexpress.Server({
     cors: true,
     forceSsl: false,
-    port: 3000
+    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.Handler('POST', async (req, res) => {
-      console.log(req.body);
-      res.json(await testTypedHandler.addResponse(req.body));
-    })
+    new smartexpress.HandlerTypedRouter(testTypedRouter as any) // the "any" is testspecific, since smartexpress ships with its own version of typedrequest.
   );
 });
 
@@ -52,7 +53,7 @@ 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);

ts/index.ts

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

ts/typedrequest.classes.typedhandler.ts

@@ -1,7 +1,7 @@
 import * as plugins from './typedrequest.plugins';
 import { TypedResponseError } from './typedrequest.classes.typedresponseerror';
 
-type THandlerFunction<T extends plugins.typedRequestInterfaces.ITypedRequest> = (
+export type THandlerFunction<T extends plugins.typedRequestInterfaces.ITypedRequest> = (
   requestArg: T['request']
 ) => Promise<T['response']>;
 
@@ -28,7 +28,7 @@ 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 {
@@ -39,7 +39,7 @@ export class TypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest
     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,16 +1,36 @@
 import * as plugins from './typedrequest.plugins';
 import { TypedResponseError } from './typedrequest.classes.typedresponseerror';
 import { TypedRouter } from './typedrequest.classes.typedrouter';
+import { TypedTarget } from './typedrequest.classes.typedtarget';
+
+const webrequestInstance = new plugins.webrequest.WebRequest();
 
 export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest> {
-  public typedRouterRef: TypedRouter;
-  public webrequest = new plugins.webrequest.WebRequest();
-  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;
+  /**
+   * 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.typedTarget = postTarget;
+    }
     this.method = methodArg;
   }
 
@@ -24,12 +44,17 @@ export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest
       response: null,
       correlation: {
         id: plugins.isounique.uni(),
-        phase: 'request'
-      }
+        phase: 'request',
+      },
     };
 
-    const response = await this.webrequest.postJson(this.urlEndPoint, payload);
-    const responseBody: T = response;
+    let responseBody: plugins.typedRequestInterfaces.ITypedRequest;
+    if (this.urlEndPoint) {
+      const response = await webrequestInstance.postJson(this.urlEndPoint, payload);
+      responseBody = response;
+    } else {
+      responseBody = await this.typedTarget.post(payload);
+    }
     if (responseBody.error) {
       console.error(
         `Got an error ${responseBody.error.text} with data ${JSON.stringify(
@@ -49,13 +74,4 @@ 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.typedrouter.ts

@@ -9,24 +9,15 @@ 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 typedRequestMap = new plugins.lik.ObjectMap<TypedRequest<any>>();
-
   public handlerMap = new plugins.lik.ObjectMap<
-    TypedHandler<plugins.typedRequestInterfaces.ITypedRequest>
+    TypedHandler<any & 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);
-    }
-  }
-
+  public fireEventInterestMap = new plugins.lik.InterestMap<
+    string,
+    plugins.typedRequestInterfaces.ITypedRequest
+  >((correlationId: string) => correlationId);
 
   /**
    * adds the handler to the routing map
@@ -51,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 {
@@ -69,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((typedRouterArg) => {
+        if (!typedHandler && !checkedRouters.includes(typedRouterArg)) {
+          typedHandler = typedRouterArg.getTypedHandlerForMethod(methodArg, checkedRouters);
+        }
       });
-
-      if (!typedHandler) {
-        this.routerMap.getArray().forEach((typedRouter) => {
-          if (!typedHandler) {
-            typedHandler = typedRouter.getTypedHandlerForMethod(methodArg, false);
-          }
-        });
-      }
     }
 
     return typedHandler;
@@ -97,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 === 'request') {
+  public async routeAndAddResponse<T extends plugins.typedRequestInterfaces.ITypedRequest = any>(typedRequestArg: T): Promise<T> {
+    if (!typedRequestArg?.correlation?.phase || typedRequestArg.correlation.phase === 'request') {
       const typedHandler = this.getTypedHandlerForMethod(typedRequestArg.method);
 
       if (!typedHandler) {
@@ -112,7 +101,13 @@ export class TypedRouter {
 
       typedRequestArg = await typedHandler.addResponse(typedRequestArg);
     } else if (typedRequestArg.correlation.phase === 'response') {
-
+      this.fireEventInterestMap
+        .findInterest(typedRequestArg.correlation.id)
+        ?.fullfillInterest(typedRequestArg);
+    } else {
+      console.log('received weirdly shaped request');
+      console.log(typedRequestArg);
+      return null
     }
     return typedRequestArg;
   }

ts/typedrequest.classes.typedtarget.ts

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

@@ -7,6 +7,7 @@ export { typedRequestInterfaces };
 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';
 
-export { isounique, lik, smartdelay, webrequest };
+export { isounique, lik, smartdelay, smartpromise, webrequest };