Merge pull request #6 from StrontiumJS/master

sync

Author: Findeton

package.json

@@ -1,6 +1,6 @@
 {
   "name": "strontium",
-  "version": "2.7.7",
+  "version": "2.8.0",
   "description": "Strontium is a TypeScript toolkit for High Performance API servers built for Production not Projects.",
   "main": "lib/src/index.js",
   "types": "lib/src/index.d.ts",

src/http/abstract/RouterMap.ts

@@ -5,4 +5,5 @@ export type RouterMap = Array<{
     method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE" | "OPTIONS"
     route: string
     endpointController: ConstructorOf<EndpointController>
+    metadata?: { [key: string]: any }
 }>

src/http/drivers/FastifyServer.ts

@@ -21,15 +21,22 @@ export class FastifyServer implements Process {
         private port: number = 8080,
         private host: string = "127.0.0.1"
     ) {
-        for (let route of routes) {
+        /*
+            To handle limitations in Find My Way (Fastify's internal routing library)
+            Strontium provides a preprocess format for routes to prevent certain conflicts.
+         */
+        let processedRoutes = FastifyServer.preProcessRoutes(routes)
+
+        for (let route of processedRoutes) {
             switch (route.method) {
                 case "GET":
                     this.server.get(
                         route.route,
                         this.requestHandler(
                             route.endpointController,
                             route.route,
-                            "GET"
+                            "GET",
+                            route.metadata
                         )
                     )
                     break
@@ -39,7 +46,8 @@ export class FastifyServer implements Process {
                         this.requestHandler(
                             route.endpointController,
                             route.route,
-                            "POST"
+                            "POST",
+                            route.metadata
                         )
                     )
                     break
@@ -49,7 +57,8 @@ export class FastifyServer implements Process {
                         this.requestHandler(
                             route.endpointController,
                             route.route,
-                            "PATCH"
+                            "PATCH",
+                            route.metadata
                         )
                     )
                     break
@@ -59,7 +68,8 @@ export class FastifyServer implements Process {
                         this.requestHandler(
                             route.endpointController,
                             route.route,
-                            "PUT"
+                            "PUT",
+                            route.metadata
                         )
                     )
                     break
@@ -69,7 +79,8 @@ export class FastifyServer implements Process {
                         this.requestHandler(
                             route.endpointController,
                             route.route,
-                            "DELETE"
+                            "DELETE",
+                            route.metadata
                         )
                     )
                     break
@@ -79,14 +90,100 @@ export class FastifyServer implements Process {
                         this.requestHandler(
                             route.endpointController,
                             route.route,
-                            "OPTIONS"
+                            "OPTIONS",
+                            route.metadata
                         )
                     )
                     break
             }
         }
     }
 
+    public static preProcessRoutes(routes: RouterMap): RouterMap {
+        let processedRoutes: RouterMap = []
+        for (let route of routes) {
+            // Check if there are any enum param blocks
+            let enumeratedBlocks = route.route.match(
+                /{([a-zA-Z0-9_-]*)\|([a-zA-Z0-9_,-]*)}/g
+            )
+
+            if (enumeratedBlocks === null) {
+                processedRoutes.push(route)
+            } else {
+                const generatePermutations = (
+                    index: number
+                ): Array<Array<string>> => {
+                    // Typescript correctly identifies this function may run when enumeratedBlocks is null
+                    // however within this context that is not possible - so ! to overcome
+                    let currentBlock = enumeratedBlocks![index]
+
+                    let childPermutations: Array<Array<string>> = []
+                    if (index < enumeratedBlocks!.length - 1) {
+                        childPermutations = generatePermutations(index + 1)
+                    }
+
+                    let permutations: Array<Array<string>> = []
+
+                    // Use a more direct method because the absence of "matchAll" in Node would make the RegEx method uglier
+                    let fieldContents = currentBlock
+                        .replace("{", "")
+                        .replace("}", "")
+
+                    let [
+                        fieldName,
+                        serializedFieldValues,
+                    ] = fieldContents.split("|")
+                    let fieldValues = serializedFieldValues.split(",")
+
+                    for (let value of fieldValues) {
+                        if (childPermutations.length === 0) {
+                            permutations.push([value])
+                        } else {
+                            for (let childPermutation of childPermutations) {
+                                permutations.push([value, ...childPermutation])
+                            }
+                        }
+                    }
+
+                    return permutations
+                }
+
+                let routePermutations = generatePermutations(0)
+
+                for (let permutation of routePermutations) {
+                    let pathPermutation = route.route
+                    let parameters: { [key: string]: string } = {
+                        ...(route.metadata || {}),
+                    }
+
+                    for (let i = 0; i < enumeratedBlocks.length; i++) {
+                        let currentBlock = enumeratedBlocks[i]
+                        let fieldContents = currentBlock
+                            .replace("{", "")
+                            .replace("}", "")
+                        let [fieldName] = fieldContents.split("|")
+
+                        parameters[fieldName] = permutation[i]
+
+                        pathPermutation = pathPermutation.replace(
+                            currentBlock,
+                            permutation[i]
+                        )
+                    }
+
+                    processedRoutes.push({
+                        endpointController: route.endpointController,
+                        method: route.method,
+                        route: pathPermutation,
+                        metadata: parameters,
+                    })
+                }
+            }
+        }
+
+        return processedRoutes
+    }
+
     public isHealthy(): boolean {
         return this.isAlive
     }
@@ -147,7 +244,8 @@ export class FastifyServer implements Process {
     protected requestHandler(
         controller: ConstructorOf<EndpointController>,
         path: string,
-        method: string
+        method: string,
+        routeMetadata: { [key: string]: any } = {}
     ): (
         request: Fastify.FastifyRequest<any, any, any, any, any>,
         response: Fastify.FastifyReply<any>
@@ -197,7 +295,10 @@ export class FastifyServer implements Process {
                     headers: request.headers,
                     query: request.query,
                     params: request.params,
-                    meta: this.getRequestMetadata(request),
+                    meta: {
+                        ...routeMetadata,
+                        ...this.getRequestMetadata(request),
+                    },
                 })
 
                 rawResponse = await endpointController.handle(validatedInput)

src/query/abstract/Filter.ts

@@ -4,11 +4,14 @@ export type FieldFilter<P extends keyof T, T> =
     | {
           $in?: Array<T[P]>
           $nin?: Array<T[P]>
+          $eq?: T[P]
+          // TODO: Review if the null type on $neq is necessary
           $neq?: T[P] | null
           $gt?: T[P]
           $gte?: T[P]
           $lt?: T[P]
           $lte?: T[P]
+          $contains?: T[P]
       }
     | T[P]
 

src/query/drivers/sql/SQLFilterCompiler.ts

@@ -39,7 +39,9 @@ export const compileSQLFilter: FilterCompiler<[string, Array<any>]> = (
 
         let subquery = filter[field]
 
-        if (subquery === null) {
+        if (subquery === undefined) {
+            continue
+        } else if (subquery === null) {
             queries.push(["?? IS NULL", [field]])
         } else if (subquery.$in !== undefined) {
             if (subquery.$in.length === 0) {
@@ -76,6 +78,10 @@ export const compileSQLFilter: FilterCompiler<[string, Array<any>]> = (
             queries.push(["?? < ?", [field, subquery.$lt]])
         } else if (subquery.$lte !== undefined) {
             queries.push(["?? <= ?", [field, subquery.$lte]])
+        } else if (subquery.$contains !== undefined) {
+            queries.push(["?? LIKE ?", [field, `%${subquery.$contains}%`]])
+        } else if (subquery.$eq !== undefined) {
+            queries.push(["?? = ?", [field, subquery.$eq]])
         } else {
             queries.push(["?? = ?", [field, subquery]])
         }

src/query/drivers/sql/TableRepository.ts

@@ -8,6 +8,7 @@ import {
 } from "../../../datastore"
 import { injectable } from "inversify"
 import { isUndefined, omitBy } from "lodash"
+import { Logger } from "../../../logging"
 
 import { Filter, compileSQLFilter } from "../.."
 
@@ -31,7 +32,8 @@ export abstract class TableRepository<
         protected store: SQLStore,
         protected tableName: string,
         protected queryFields: Array<keyof T>,
-        protected primaryKeyField: K
+        protected primaryKeyField: K,
+        protected logger?: Logger
     ) {
         super()
 
@@ -114,6 +116,7 @@ export abstract class TableRepository<
         } = {},
         connection: SQLStore = this.store
     ): Promise<Array<T>> {
+        let startTime = process.hrtime()
         let [filterQuery, filterParameters] = compileSQLFilter(filter)
         let parameters = [this.tableName, ...filterParameters]
 
@@ -150,6 +153,8 @@ export abstract class TableRepository<
             processedQuery,
             processedParameters
         )
+
+        this.recordQueryTime(processedQuery, startTime)
         return results
     }
 
@@ -208,4 +213,25 @@ export abstract class TableRepository<
     async generateID(): Promise<any> {
         return undefined
     }
+
+    protected recordQueryTime(
+        queryString: string,
+        startTime: [number, number]
+    ): void {
+        if (this.logger !== undefined) {
+            let runtime = process.hrtime(startTime)
+
+            this.logger.debug(
+                `[REPOSITORY - QUERY - DIAGNOSTICS] ${
+                    this.tableName
+                } query complete - ${runtime[0]} s and ${runtime[1] /
+                    1000000} ms`,
+                {
+                    query: queryString,
+                    seconds: runtime[0],
+                    milliseconds: runtime[1] / 1000000,
+                }
+            )
+        }
+    }
 }