Adapt to mr

Author: Immanuel Pelzer

.gitignore

@@ -1 +1,2 @@
 node_modules
+DS_Store

.vscode/launch.json

@@ -0,0 +1,20 @@
+{
+    // Verwendet IntelliSense zum Ermitteln möglicher Attribute.
+    // Zeigen Sie auf vorhandene Attribute, um die zugehörigen Beschreibungen anzuzeigen.
+    // Weitere Informationen finden Sie unter https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Run AVA test",
+            "program": "${workspaceFolder}/node_modules/ava/profile.js",
+            "args": [
+              "${file}"
+            ],
+            "skipFiles": [
+                "<node_internals>/**/*.js"
+            ]
+        }
+    ]
+}

src/components/app.js components/app.js

@@ -6,31 +6,37 @@ const upstreamCote = require('@cloud/cote')
 const debug = require('debug')('cote-http-req')
 const config = require('../config')
 
-let env = '-'
 
 class Requester {
   constructor(options, discoveryOptions = {}) {
     this.key = options.key || 'default'
-    this.targetHostname = options.hostname || this.key
+    this.uri = options.uri
+    this.port = options.port || config.http.port
+    if (this.uri) {
+      if (!this.uri.includes('http://') && !this.uri.includes('https://')) {
+        throw new Error('Invalid uri format. Needs to be prefixed by https:// or http://')
+      }
+    }
     if (!options.name) options.name = `Requester ${crypto.randomBytes(3).toString('hex')}`
-    // Create a new upstream cote responder while preserving passed env
-
-    upstreamCote.Requester.constructor._environment = `${env}:`
     this.cote = new upstreamCote.Requester(options, { log: false, ...discoveryOptions })
   }
 
-  static setEnvironment(environment) {
-    if (!environment) return
-    env = environment
-  }
-
   async send(payload, callback) {
     debug('sending', payload)
     const key = escape(this.key)
     let httpRes
+
+    // If uri is not set use normal cote
+    if (!this.uri) {
+      debug('using cote')
+      if (callback) return this.cote.send(payload, callback)
+      return this.cote.send(payload)
+    }
+
     // Try to communicate over http
     try {
-      httpRes = await got(`http://${this.targetHostname}:${config.http.port}/${env}/${key}/${payload.type}`, {
+      debug('using http')
+      httpRes = await got(`${this.uri}:${this.port}/${key}/${payload.type}`, {
         method: 'POST',
         headers: {
           'content-type': 'application/json'
@@ -39,13 +45,6 @@ class Requester {
       })
     } catch (error) {
       debug(error)
-      // If there are 404s use cote instead
-      if (error.statusCode == 404) {
-        debug('using cote fallback')
-        if (callback) return this.cote.send(payload, callback)
-        return this.cote.send(payload)
-      }
-
       throw error
     }
 

src/components/requester.js components/requester.js

@@ -5,47 +5,31 @@ const upstreamCote = require('@cloud/cote')
 const debug = require('debug')('cote-http-res')
 const app = require('./app')
 
-const occupiedOn = {}
-
 let responders = {}
 
-let env = '-'
-
 class Responder {
   constructor(options, discoveryOptions = {}) {
     this.key = options.key || 'default'
     // Is namespaced Responder which cant be handled yet, fallback to upstream cote
     if (!options.name) options.name = `Responder ${crypto.randomBytes(3).toString('hex')}`
     if (!responders[this.key]) {
-      // Create a new upstream cote responder while preserving passed env
-      upstreamCote.Responder.constructor._environment = `${env}:`
       const rsp = new upstreamCote.Responder(options, { log: false, ...discoveryOptions })
       // Return upstream cote if undhandled use case (namespaced and respondsTo for now)
       if (options.namespace || options.respondsTo) return rsp
       responders[this.key] = rsp
     }
   }
 
-  static setEnvironment(environment) {
-    if (!environment) return
-    env = environment
-  }
-
   on(name, fn) {
     debug('did setup responder', name)
     // Validate expected inputs
     if (!name || typeof name != 'string') throw new Error('Invalid first parameter, needs to be a string')
     if (!fn || typeof fn != 'function') throw new Error('Invalid second parameter, needs to be function')
     // Setup this also in cote
     responders[this.key].on(name, fn)
-    // This library can't handle Responders targeted at a Sockend
-    if (this.upstreamCoteUsage) return
-    // Check if this name is occupied already
-    if (occupiedOn[name]) throw new Error(`on(${name},fn) is already occupied`)
-    occupiedOn[name] = true
     // Setup express endpoint
     name = escape(name)
-    app.post(`/${env}/${this.key}/${name}`, (request, response) => {
+    app.post(`/${this.key}/${name}`, (request, response) => {
       debug('recieved req', request.body)
       function callback(err, res) {
         if (!err) return send(res)

src/components/responder.js components/responder.js

@@ -0,0 +1,9 @@
+/* eslint-disable global-require */
+/* eslint-disable no-underscore-dangle */
+const cote = require('@cloud/cote')
+
+const coteHttp = { ...cote }
+coteHttp.Requester = require('./components/requester')
+coteHttp.Responder = require('./components/responder')
+
+module.exports = coteHttp

src/config/index.js config/index.js

@@ -1,10 +1,10 @@
 {
   "name": "@immanuel/cote-http",
-  "version": "0.0.7",
+  "version": "0.0.11",
   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "ava test/*.test.js --verbose"
+    "test": "ava test/*.test.js --verbose --serial"
   },
   "publishConfig": {
     "registry": "https://npm.unueng.com"

index.js

@@ -1,15 +1,11 @@
 /* eslint-disable global-require */
-import r from 'randomstring'
-
 process.env.COTE_HTTP_PORT = 3334
 
 const test = require('ava')
+const coteHttp = require('../')
+const cote = require('@cloud/cote')
 
 test('req res model requester does fallback to cote on 404', async(t) => {
-  const environment = r.generate()
-
-  const coteHttp = require('../src/index')({ environment })
-  const cote = require('@cloud/cote')({ environment })
   const responder = new cote.Responder({ key: 'localhost', name: 'test responder' })
   const request = { type: 'test11' }
   const response = 'bla'
@@ -22,15 +18,11 @@ test('req res model requester does fallback to cote on 404', async(t) => {
   })
 
   const res1 = await requester.send(request)
+  t.falsy(res1.http)
   t.is(response, res1)
 })
 
 test('req res model cote responders are compatible with cote-http', async(t) => {
-  const environment = r.generate()
-
-  const coteHttp = require('../src/index')({ environment })
-  const cote = require('@cloud/cote')({ environment })
-
   const responder = new coteHttp.Responder({ key: 'localhost', name: 'test responder' })
 
   const request = { type: 'test23' }
@@ -47,4 +39,13 @@ test('req res model cote responders are compatible with cote-http', async(t) =>
 
   const res1 = await requester.send(request)
   t.is(res1, response)
+
+  const requester2 = new coteHttp.Requester({
+    key: 'localhost',
+    uri: 'http://localhost',
+    name: 'test requester'
+  })
+
+  const res2 = await requester2.send(request)
+  t.is(response, res2)
 })