feat: Route Class and add formDataToJson to Parser

Author: jlenon7

README.md

@@ -25,6 +25,32 @@ yarn add @secjs/utils
 
 ## Classes Usage
 
+### Route
+
+> Use Route to manipulate paths, getParams, getQueryParams, create route matcher RegExp etc.
+
+```js
+import { Route } from '@secjs/utils'
+
+const route = new Route()
+const absolutePath = '/tests/:id/users/:user_id'
+const path = '/tests/1/users/2?page=1&limit=10'
+
+route.getQueryString(path) // ?page=1&limit=10
+route.removeQueryParams(path) // /tests/1/users/2
+route.getQueryParamsValue(path) // { page: '1', limit: '10' }
+route.getQueryParamsName(path) // ['path', 'limit']
+route.getParamsValue(absolutePath, path) // { id: '1', user_id: '10' }
+route.getParamsName(absolutePath) // ['id', 'user_id']
+
+const regExpMatcher = route.createMatcher(absolutePath) // /^(?:\/tests\b)(?:\/[\w-]+)(?:\/users\b)(?:\/[\w-]+)$/
+
+regExpMatcher.test(path) // false - because of queryParams
+regExpMatcher.test(route.removeQueryParams(path)) // true
+```
+
+---
+
 ### Blacklist
 
 > Use Blacklist to add, find and remove values from a blacklist/whitelist file
@@ -121,11 +147,15 @@ console.log(parsed2) // 21313
 
 const object = {
   joao: 'joao',
-  lenon: 'lenon',
+  email: 'lenonsec7@gmail.com',
 }
 const parsed3 = parser.jsonToFormData(object)
 
-console.log(parsed3) // &joao=joao&lenon=lenon
+console.log(parsed3) // &joao=joao&email=lenonSec7%40gmail.com
+
+const parsed4 = parser.formDataToJson('?joao=joao&email=lenonSec7%40gmail.com')
+
+console.log(parsed4) // { joao: 'joao', email: 'lenonsec7@gmail.com' }
 ```
 
 ---

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@secjs/utils",
-  "version": "1.2.7",
+  "version": "1.2.8",
   "description": "",
   "scripts": {
     "build": "tsc",

src/Classes/Parser.ts

@@ -34,7 +34,7 @@ export class Parser {
   }
 
   /**
-   * Parse an object form data
+   * Parse an object to form data
    *
    * @param object The object to parse
    * @return The object parsed to form data
@@ -46,4 +46,24 @@ export class Parser {
       }, '')
       .substring(1)
   }
+
+  /**
+   * Parse form data to json
+   *
+   * @param formData The form data to parse
+   * @return The form data parsed to object
+   */
+  formDataToJson(formData: string): any {
+    const object = {}
+
+    if (formData.startsWith('?')) formData = formData.replace('?', '')
+
+    formData.split('&').forEach(queries => {
+      const query = queries.split('=')
+
+      object[decodeURIComponent(query[0])] = decodeURIComponent(query[1])
+    })
+
+    return object
+  }
 }

src/Classes/Route.ts

@@ -0,0 +1,142 @@
+import { Parser } from './Parser'
+
+export class Route {
+  /**
+   * Get the query string in form data format
+   *
+   * @param route The route to get the query string
+   * @return The string with query string
+   */
+  getQueryString(route: string): string {
+    const queryIndex = route.search(/\?(.*)/)
+
+    if (queryIndex === -1) return route
+
+    return route.substring(queryIndex)
+  }
+
+  /**
+   * Remove query params from the route
+   *
+   * @param route The route to remove the queryParams
+   * @return The route without the query params
+   */
+  removeQueryParams(route: string): string {
+    if (this.getQueryString(route) === route) return route
+
+    return route.replace(this.getQueryString(route), '')
+  }
+
+  /**
+   * Get object with ?&queryParams values from route
+   *
+   * @param route The route to get the queryParams
+   * @return The object of queryParams found inside route
+   */
+  getQueryParamsValue(route: string): any {
+    return new Parser().formDataToJson(this.getQueryString(route))
+  }
+
+  /**
+   * Get array with ?&queryParams name from route
+   *
+   * @param route The route to get the queryParams
+   * @return The array name of queryParams found inside route
+   */
+  getQueryParamsName(route: string): string[] {
+    const queryNames = []
+    let queryString = this.getQueryString(route)
+
+    if (queryString.startsWith('?')) queryString = queryString.replace('?', '')
+
+    queryString
+      .split('&')
+      .forEach(queries =>
+        queryNames.push(decodeURIComponent(queries.split('=')[0])),
+      )
+
+    return queryNames
+  }
+
+  /**
+   * Get object with :params values from route
+   *
+   * @param route The route to get the params
+   * @return The object of params found inside route
+   */
+  getParamsValue(routeWithParams: string, routeWithValues: string): any {
+    routeWithParams = this.removeQueryParams(routeWithParams)
+    routeWithValues = this.removeQueryParams(routeWithValues)
+
+    const params = {}
+
+    const routeWithParamsArray = routeWithParams.split('/')
+    const routeWithValuesArray = routeWithValues.split('/')
+
+    if (routeWithParamsArray.length !== routeWithValuesArray.length) {
+      throw new Error('DIFFERENT_ROUTES')
+    }
+
+    routeWithParamsArray.forEach((param, i) => {
+      if (!param.startsWith(':')) return
+
+      params[decodeURIComponent(param.replace(':', ''))] = decodeURIComponent(
+        routeWithValuesArray[i],
+      )
+    })
+
+    return params
+  }
+
+  /**
+   * Get array with :params name from route
+   *
+   * @param route The route to get the params
+   * @return The array name of params found inside route
+   */
+  getParamsName(route: string): string[] {
+    route = this.removeQueryParams(route)
+
+    const replaceDots = (value: string): string =>
+      decodeURIComponent(value.replace(':', ''))
+
+    return route.split('/').reduce((results, r) => {
+      if (r.match(':')) {
+        results.push(
+          r.includes('|') ? replaceDots(r.split('|')[0]) : replaceDots(r),
+        )
+      }
+
+      return results
+    }, [])
+  }
+
+  /**
+   * Create a matcher RegExp for any route
+   *
+   * @param route The route to create the matcher
+   * @return The matcher RegExp based on route
+   */
+  createMatcher(route: string): RegExp {
+    route = this.removeQueryParams(route)
+
+    const routeArray = route.split('/')
+
+    routeArray.forEach((r, i) => {
+      if (r === '') return
+      if (r.startsWith(':')) {
+        // Match with any value RegExp
+        routeArray[i] = `(?:\\/[\\w-]+)`
+
+        return
+      }
+
+      // Match only with value of ${r} RegExp
+      routeArray[i] = `(?:\\/${r}\\b)`
+    })
+
+    route = routeArray.join('')
+
+    return new RegExp(`^${route}$`)
+  }
+}

tests/Classes/parser.spec.ts

@@ -29,4 +29,15 @@ describe('\n Parser Class', () => {
 
     expect(formData).toBe('name=lenon&email=lenonSec7%40gmail.com')
   })
+
+  it('should parse form data to json', () => {
+    const formData = 'name=lenon&email=lenonSec7%40gmail.com'
+
+    const json = parser.formDataToJson(formData)
+
+    expect(json).toStrictEqual({
+      name: 'lenon',
+      email: 'lenonSec7@gmail.com',
+    })
+  })
 })

tests/Classes/route.spec.ts

@@ -0,0 +1,80 @@
+import { Token } from './../../src/Classes/Token'
+import { Route } from '../../src/Classes/Route'
+
+describe('\n Route Class', () => {
+  let route: Route
+
+  beforeAll(() => {
+    route = new Route()
+  })
+
+  it('should get query params in string format from the route', () => {
+    const path = '/users/1/posts?page=1&limit=10&created_at=1995-12-17T03:24:00'
+
+    expect(route.getQueryString(path)).toStrictEqual(
+      '?page=1&limit=10&created_at=1995-12-17T03:24:00',
+    )
+  })
+
+  it('should remove all query params from the route', () => {
+    const path = '/users/1/posts?page=1&limit=10&created_at=1995-12-17T03:24:00'
+
+    expect(route.removeQueryParams(path)).toStrictEqual('/users/1/posts')
+    expect(
+      route.removeQueryParams(route.removeQueryParams(path)),
+    ).toStrictEqual('/users/1/posts')
+  })
+
+  it('should get query params value from any route', () => {
+    const path = '/users/1/posts?page=1&limit=10&created_at=1995-12-17T03:24:00'
+
+    expect(route.getQueryParamsValue(path)).toStrictEqual({
+      page: '1',
+      limit: '10',
+      created_at: '1995-12-17T03:24:00',
+    })
+  })
+
+  it('should get query params names from any route', () => {
+    const path = '/users/1/posts?page=1&limit=10&created_at=1995-12-17T03:24:00'
+
+    expect(route.getQueryParamsName(path)).toStrictEqual([
+      'page',
+      'limit',
+      'created_at',
+    ])
+  })
+
+  it('should get params value from any route', () => {
+    const pathWithParams = '/users/:id/posts/:post_id?page=1&limit=10'
+    const pathWithValues = '/users/1/posts/2?page=1&limit=10'
+
+    expect(route.getParamsValue(pathWithParams, pathWithValues)).toStrictEqual({
+      id: '1',
+      post_id: '2',
+    })
+  })
+
+  it('should get params names from any route', () => {
+    const path = '/users/:id/posts/:post_id?page=1&limit=10'
+
+    expect(route.getParamsName(path)).toStrictEqual(['id', 'post_id'])
+  })
+
+  it('should create a matcher RegExp to recognize the route', () => {
+    const path = '/users/:id/posts/:post_id?page=1&limit=10'
+
+    const pathTest1 = '/users/1/posts/test'
+    const pathTest2 = '/users/1/posts/2/oi'
+    const pathTest3 = `/users/${new Token().generate()}/posts/1`
+
+    const matcher = route.createMatcher(path)
+
+    expect(matcher).toStrictEqual(
+      /^(?:\/users\b)(?:\/[\w-]+)(?:\/posts\b)(?:\/[\w-]+)$/,
+    )
+    expect(matcher.test(pathTest1)).toBe(true)
+    expect(matcher.test(pathTest2)).toBe(false)
+    expect(matcher.test(pathTest3)).toBe(true)
+  })
+})