1.0.24

.gitlab-ci.yml

@@ -30,7 +30,7 @@ snyk:
   script:
     - npmci npm prepare
     - npmci node install stable
-    - npmci command npm cache verify
+    - npmci command npm cache clean --force
     - npmci command npm install -g snyk
     - npmci command npm install --ignore-scripts
     - npmci command snyk test

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apiglobal/typedrequest",
-  "version": "1.0.8",
+  "version": "1.0.24",
   "private": false,
   "description": "make typed requests towards apis",
   "main": "dist/index.js",
@@ -15,13 +15,16 @@
   "devDependencies": {
     "@gitzone/tsbuild": "^2.0.22",
     "@gitzone/tstest": "^1.0.15",
+    "@pushrocks/smartexpress": "^3.0.40",
     "@pushrocks/tapbundle": "^3.0.13",
     "@types/node": "^12.7.2",
     "tslint": "^5.19.0",
     "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@apiglobal/typedrequest-interfaces": "^1.0.5",
+    "@apiglobal/typedrequest-interfaces": "^1.0.7",
+    "@pushrocks/lik": "^3.0.11",
+    "@pushrocks/smartjson": "^3.0.8",
     "@pushrocks/smartrequest": "^1.1.23"
   },
   "files": [

test/test.ts

@@ -1,8 +1,58 @@
 import { expect, tap } from '@pushrocks/tapbundle';
+import * as smartexpress from '@pushrocks/smartexpress';
+
 import * as typedrequest from '../ts/index';
 
-tap.test('first test', async () => {
-  typedrequest.TypedRequest;
+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'
+  });
+  expect(response.surname).to.equal('wow');
+});
+
+tap.test('should end the server', async () => {
+  await testServer.stop();
 });
 
 tap.start();

ts/index.ts

@@ -1,27 +1,3 @@
-import * as plugins from './typedrequest.plugins';
-
-export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest> {
-  public urlEndPoint: string;
-  public method: string;
-
-  // STATIC
-  constructor(urlEndPointArg: string, methodArg: T['method']) {
-    this.urlEndPoint = urlEndPointArg;
-    this.method = methodArg;
-  }
-
-  /**
-   * firest the request
-   */
-  public async fire(fireArg: T['request']): Promise<T['response']> {
-    const response = await plugins.smartrequest.request(this.urlEndPoint, {
-      method: 'POST',
-      requestBody: {
-        method: this.method,
-        request: fireArg,
-        response: null
-      }
-    });
-    return response.body.response;
-  }
-}
+export * from './typedrequest.classes.typedrequest';
+export * from './typedrequest.classes.typedhandler';
+export * from './typedrequest.classes.typedrouter';

ts/typedrequest.classes.typedhandler.ts

@@ -0,0 +1,29 @@
+import * as plugins from './typedrequest.plugins';
+
+type THandlerFunction<T extends plugins.typedRequestInterfaces.ITypedRequest> = (requestArg: T['request']) => Promise<T['response']>;
+
+/**
+ * typed handler for dealing with typed requests
+ */
+export class TypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest> {
+  public method: string;
+  private handlerFunction: THandlerFunction<T>;
+
+  constructor(methodArg: T['method'], handlerFunctionArg: THandlerFunction<T>) {
+    this.method = methodArg;
+    this.handlerFunction = handlerFunctionArg;
+  }
+
+  /**
+   * adds a response to the typedRequest
+   * @param typedRequestArg
+   */
+  public async addResponse(typedRequestArg: T) {
+    if (typedRequestArg.method !== this.method) {
+      throw new Error('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;
+    return typedRequestArg;
+  }
+}

ts/typedrequest.classes.typedrequest.ts

@@ -0,0 +1,26 @@
+import * as plugins from './typedrequest.plugins';
+
+export class TypedRequest<T extends plugins.typedRequestInterfaces.ITypedRequest> {
+  public urlEndPoint: string;
+  public method: string;
+
+  // STATIC
+  constructor(urlEndPointArg: string, methodArg: T['method']) {
+    this.urlEndPoint = urlEndPointArg;
+    this.method = methodArg;
+  }
+
+  /**
+   * firest 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
+      }
+    });
+    return response.body.response;
+  }
+}

ts/typedrequest.classes.typedrouter.ts

@@ -0,0 +1,41 @@
+import * as plugins from './typedrequest.plugins';
+
+import { TypedHandler } from './typedrequest.classes.typedhandler';
+
+/**
+ * A typed router decides on which typed handler to call based on the method
+ * specified in the typed request
+ * This is thought for reusing the same url endpoint for different methods
+ */
+export class TypedRouter {
+  public handlerMap = new plugins.lik.Objectmap<
+    TypedHandler<plugins.typedRequestInterfaces.ITypedRequest>
+  >();
+
+  /**
+   * adds the handler to the routing map
+   * @param handlerArg
+   */
+  public addTypedHandler<T extends plugins.typedRequestInterfaces.ITypedRequest>(handlerArg: TypedHandler<T>) {
+    this.handlerMap.add(handlerArg);
+  }
+
+  public async addResponse(typedRequest: plugins.typedRequestInterfaces.ITypedRequest) {
+    const typedHandler = this.handlerMap.find(handler => {
+      return handler.method === typedRequest.method;
+    });
+
+    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);
+    }
+
+    typedRequest = await typedHandler.addResponse(typedRequest);
+    return typedRequest;
+  }
+}

ts/typedrequest.plugins.ts

@@ -4,6 +4,8 @@ import * as typedRequestInterfaces from '@apiglobal/typedrequest-interfaces';
 export { typedRequestInterfaces };
 
 // pushrocks scope
+import * as lik from '@pushrocks/lik';
 import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartjson from '@pushrocks/smartjson';
 
-export { smartrequest };
+export { lik, smartrequest, smartjson };