Mongo Adapter and Custom Port fixes

.github/workflows/bump-version.yml

@@ -0,0 +1,23 @@
+name: Bump version
+on:
+  push:
+    branches:
+      - develop
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Bump version and push tag
+        id: tag_version
+        uses: mathieudutour/[email protected]
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Create a GitHub release
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ steps.tag_version.outputs.new_tag }}
+          name: Release ${{ steps.tag_version.outputs.new_tag }}
+          body: ${{ steps.tag_version.outputs.changelog }}
+
+#### https://github.com/marketplace/actions/github-tag

src/adapters/controllers/post-invoke-port.js

@@ -13,6 +13,9 @@ export default function anyInvokePortFactory (invokePort) {
       const result = await invokePort({
         port: httpRequest.params.port,
         args: httpRequest.body,
+        method: httpRequest.method,
+        headers: httpRequest.headers,
+        path: httpRequest.path,
         id: httpRequest.params.id || null
       })
 

src/adapters/datasources/datasource-mongodb.js

@@ -6,12 +6,20 @@ const HIGHWATERMARK = 50
 
 const mongodb = require('mongodb')
 const { MongoClient } = mongodb
-const { Transform, Writable } = require('stream')
-const qpm = require('query-params-mongo')
-const processQuery = qpm()
+const { DataSourceMemory } = require("./datasource-memory")
+const { Transform, Writable } = require("stream")
+const qpm = require("query-params-mongo")
+const processQuery = qpm({
+  autoDetect: [
+    { valuePattern: /^null$/i, dataType: 'nullstring' }
+  ],
+  converters: { 
+    nullstring: val=>{ return { $type: 10 } }  // reference BSON datatypes https://www.mongodb.com/docs/manual/reference/bson-types/
+  }
+})
 
-const url = process.env.MONGODB_URL || 'mongodb://localhost:27017'
-const configRoot = require('../../config').hostConfig
+const url = process.env.MONGODB_URL || "mongodb://localhost:27017"
+const configRoot = require("../../config").hostConfig
 const dsOptions = configRoot.adapters.datasources.DataSourceMongoDb.options || {
   runOffline: true,
   numConns: 2
@@ -238,7 +246,7 @@ export class DataSourceMongoDb extends DataSource {
 
   processOptions (param) {
     const { options = {}, query = {} } = param
-    return { ...options, ...processQuery(query) }
+    return { ...processQuery(query), ...options } // options must overwite the query not otherwise
   }
 
   /**

src/aegis.js

@@ -96,11 +96,13 @@ const router = {
           if (ctrl.ports) {
             for (const portName in ctrl.ports) {
               const port = ctrl.ports[portName]
+              const specPortMethods = port?.methods?.join('|') || ""
+
               if (port.path) {
                 routeOverrides.set(port.path, portName)
               }
 
-              if (checkAllowedMethods(ctrl, method)) {
+              if (checkAllowedMethods(ctrl, method) && (!port.methods || (specPortMethods.includes(method.toLowerCase()))) ) {
                 routes.set(port.path || path(ctrl.endpoint), {
                   [method]: adapter(ctrl.fn)
                 })
@@ -131,6 +133,8 @@ const router = {
 }
 
 function makeRoutes () {
+  router.adminRoute(getConfig, http)
+  router.userRoutes(getRoutes)
   router.autoRoutes(endpoint, 'get', liveUpdate, http)
   router.autoRoutes(endpoint, 'get', getModels, http)
   router.autoRoutes(endpoint, 'post', postModels, http)
@@ -146,8 +150,6 @@ function makeRoutes () {
   router.autoRoutes(endpointPortId, 'patch', anyInvokePorts, http, true)
   router.autoRoutes(endpointPortId, 'delete', anyInvokePorts, http, true)
   router.autoRoutes(endpointPortId, 'get', anyInvokePorts, http, true)
-  router.adminRoute(getConfig, http)
-  router.userRoutes(getRoutes)
   console.log(routes)
 }
 

src/domain/use-cases/invoke-port.js

@@ -33,33 +33,46 @@ export default function makeInvokePort ({
   }
   /**
    *
-   * @param {{id:string,model:import('..').Model,args:string[],port:string}} input
+   * @param {{id:String,model:import('..').Model,args:String[],port:String,method:String,headers:Array}} input
    * @returns
    */
   return async function invokePort (input) {
     if (isMainThread) {
       return threadpool.runJob(invokePort.name, input, modelName)
     } else {
       try {
-        const { id = null, port = null} = input;
+        let { id = null, port = null, method, path } = input;
         const service = await findModelService(id)
-
         if (!service) {
-          throw new Error('could not find service')
+          throw new Error('could not find a service associated with given id')
         } 
-
+
+        const specPorts = service.getPorts();
         if(!port) {
-          const specPorts = service.getPorts();
-          const path = context['requestContext'].getStore().get('path');
-          const [ [ portName ] ] = Object.entries(specPorts).filter((port) => port[1].path === path);
-          if(!portName) {
-            throw new Error('no port specified');
-          }
-          if(!service[portName]) {
-            throw new Error('no port found');
+          for(const p of Object.entries(specPorts)) {
+            if(!p[1].path) {
+              continue;
+            }
+            if (pathsMatch(p[1].path, path)) {
+              port = p[0];
+              break;
+            }
           }
+        }
+
+        if(!port) {
+          throw new Error('the port is undefined')
+        }
+        if(!service[port]) {
+          throw new Error('the port or record ID is invalid')
+        }
 
-          return await service[portName](input);
+        const specPortMethods = specPorts[port]?.methods.join('|').toLowerCase();
+        if (specPortMethods && !(specPortMethods.includes(method.toLowerCase()))) {
+          throw new Error('invalid method for given port');
+        }
+        if (specPorts[port]?.path && !pathsMatch(specPorts[port].path, path)) {
+          throw new Error('invalid path for given port');
         }
 
         return await service[port](input)
@@ -68,4 +81,40 @@ export default function makeInvokePort ({
       }
     }
   }
+}
+
+// Performant way of checking if paths are the same
+// given one path with params and one with the param pattern
+// this accounts for route params
+// since a route param can be anything, we can just compare 
+/// each path segment skipping over the param field
+function pathsMatch(pathWithParamRegex, pathWithParams) {
+  const splitPathWithParams = pathWithParams.split('/');
+  const splitPathWithParamRegex = pathWithParamRegex.split('/');
+
+  // We know if the length is different, the paths are different
+  if(splitPathWithParams.length !== splitPathWithParamRegex.length) {
+    return false;
+  }
+
+  // we loop through the path with params and check if the path with param regex and the called path match
+  // if they do not match, we return false
+  // if we get to a segment with a route param we continue
+  // if we get to the end of the loop and all segments match, we return true
+  for (let index = 0; index < splitPathWithParams.length; index++) {
+    const param = splitPathWithParams[index];
+    const paramRegex = splitPathWithParamRegex[index];
+
+    // regex path includes colon meaning route param so we continue
+    if(paramRegex.includes(':')) {
+      continue;
+    }
+
+    // if not equal, we return false the paths don't match
+    if(param !== paramRegex) {
+      return false;
+    }
+  }
+
+  return true;
 }