acrylblends 0.3.0 → 0.4.0

package/plugins/acryl-router/src/core/router/reg-exp-router/router.ts

@@ -0,0 +1,174 @@
+import type { Router } from '../../router.ts'
+import {
+  MESSAGE_MATCHER_IS_ALREADY_BUILT,
+  METHOD_NAME_ALL,
+  UnsupportedPathError,
+} from '../../router.ts'
+import { checkOptionalParameter } from '../../utils/url.ts'
+import { createNullObject } from '../utils.ts'
+import type { HandlerData, StaticMap, Matcher, MatcherMap } from './matcher.ts'
+import { match, emptyParam } from './matcher.ts'
+import {
+  LABEL_REG_EXP_STR,
+  ONLY_WILDCARD_REG_EXP_STR,
+  PATH_ERROR,
+  TAIL_WILDCARD_REG_EXP_STR,
+} from './node.ts'
+import { Trie } from './trie.ts'
+
+type HandlerWithMetadata<T> = [T, string] // [handler, path]
+
+let wildcardRegExpCache: Record<string, RegExp> = createNullObject()
+function buildWildcardRegExp(path: string): RegExp {
+  return (wildcardRegExpCache[path] ??= new RegExp(
+    `^${path.replace(
+      /\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g,
+      (match, metaChar) =>
+        metaChar
+          ? `\\${metaChar}`
+          : match === '/*'
+            ? TAIL_WILDCARD_REG_EXP_STR
+            : match === '*'
+              ? ONLY_WILDCARD_REG_EXP_STR
+              : `/:${LABEL_REG_EXP_STR}`
+    )}$`
+  ))
+}
+
+function findMiddleware<T>(middleware: Record<string, T[]>, path: string): T[] | undefined {
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+    if (buildWildcardRegExp(k).test(path)) {
+      return [...middleware[k]]
+    }
+  }
+
+  return undefined
+}
+
+export class RegExpRouter<T> implements Router<T> {
+  name: string = 'RegExpRouter'
+  #middleware?: Record<string, Record<string, HandlerWithMetadata<T>[]>>
+  #routes?: Record<string, Record<string, HandlerWithMetadata<T>[]>>
+  #tries?: Record<string, Trie>
+
+  constructor() {
+    this.#middleware = { [METHOD_NAME_ALL]: createNullObject() }
+    this.#routes = { [METHOD_NAME_ALL]: createNullObject() }
+    this.#tries = { [METHOD_NAME_ALL]: new Trie() }
+  }
+
+  #insertPath(method: string, path: string) {
+    try {
+      this.#tries![method].insert(path, !/\*|\/:/.test(path))
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e
+    }
+  }
+
+  add(method: string, path: string, handler: T) {
+    const middleware = this.#middleware
+    const routes = this.#routes!
+
+    if (!middleware) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT)
+    }
+
+    if (!middleware[method]) {
+      this.#tries![method] = new Trie()
+      for (const handlerMap of [middleware, routes]) {
+        handlerMap[method] = createNullObject()
+        for (const p in handlerMap[METHOD_NAME_ALL]) {
+          handlerMap[method][p] = [...handlerMap[METHOD_NAME_ALL][p]]
+          this.#insertPath(method, p)
+        }
+      }
+    }
+
+    if (path === '/*') {
+      path = '*'
+    }
+    const methods = method === METHOD_NAME_ALL ? Object.keys(middleware) : [method]
+
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path)
+      for (const m of methods) {
+        if (!middleware[m][path]) {
+          this.#insertPath(m, path)
+          middleware[m][path] =
+            findMiddleware(middleware[m], path) ||
+            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+            []
+        }
+      }
+      for (const handlerMap of [middleware, routes]) {
+        for (const m of methods) {
+          for (const p in handlerMap[m]) {
+            re.test(p) && handlerMap[m][p].push([handler, path])
+          }
+        }
+      }
+
+      return
+    }
+
+    const paths = checkOptionalParameter(path) || [path]
+    for (const path of paths) {
+      for (const m of methods) {
+        if (!routes[m][path]) {
+          this.#insertPath(m, path)
+          routes[m][path] =
+            findMiddleware(middleware[m], path) ||
+            findMiddleware(middleware[METHOD_NAME_ALL], path) ||
+            []
+        }
+        routes[m][path].push([handler, path])
+      }
+    }
+  }
+
+  match: typeof match<Router<T>, T> = match
+
+  protected buildAllMatchers(): MatcherMap<T> {
+    const matchers: MatcherMap<T> = createNullObject()
+
+    for (const method of Object.keys(this.#routes!)) {
+      matchers[method] = this.#buildMatcher(method)
+    }
+
+    // Release cache
+    this.#middleware = this.#routes = this.#tries = undefined
+    wildcardRegExpCache = createNullObject()
+
+    return matchers
+  }
+
+  #buildMatcher(method: string): Matcher<T> {
+    const middleware = this.#middleware![method]
+    const routes = this.#routes![method]
+
+    const trie = this.#tries![method]
+    const staticMap: StaticMap<T> = createNullObject()
+    const handlerData: HandlerData<T>[] = []
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp()
+
+    for (const r of [middleware, routes]) {
+      for (const path in r) {
+        const handlers = r[path]
+        const pathData = trie.paths[path]
+        if (!pathData) {
+          staticMap[path] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam]
+          continue
+        }
+        handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [
+          h,
+          trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
+            map[key] = paramReplacementMap[pathData[1][i][1]]
+            return map
+          }, createNullObject()),
+        ])
+      }
+    }
+
+    return [regexp, indexReplacementMap.map((i) => handlerData[i]), staticMap] as Matcher<T>
+  }
+}

package/plugins/acryl-router/src/core/router/reg-exp-router/trie.ts

@@ -0,0 +1,84 @@
+import { createNullObject } from '../utils.ts'
+import type { Context, ParamAssocArray } from './node.ts'
+import { Node } from './node.ts'
+
+export type ReplacementMap = number[]
+
+export class Trie {
+  #context: Context = { varIndex: 0 }
+  #root: Node = new Node()
+  #index: number = 0
+  // dynamic path -> [handler index, param assoc]; static paths are not registered
+  paths: Record<string, [number, ParamAssocArray]> = createNullObject()
+
+  insert(path: string, isStatic: boolean): void {
+    if (isStatic) {
+      // a static path has no pattern; every character is a literal token
+      this.#root.insert(path.split(''), 0, [], this.#context, true)
+      return
+    }
+
+    const paramAssoc: ParamAssocArray = []
+
+    const groups: [string, string][] = [] // [mark, original string]
+    let markedPath = path
+    for (let i = 0; ;) {
+      let replaced = false
+      markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`
+        groups[i] = [mark, m]
+        i++
+        replaced = true
+        return mark
+      })
+      if (!replaced) {
+        break
+      }
+    }
+
+    /**
+     *  - pattern (:label, :label{0-9]+}, ...)
+     *  - /* wildcard
+     *  - character
+     */
+    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || []
+    for (let i = groups.length - 1; i >= 0; i--) {
+      const [mark] = groups[i]
+      for (let j = tokens.length - 1; j >= 0; j--) {
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1])
+          break
+        }
+      }
+    }
+
+    this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false)
+    this.paths[path] = [this.#index++, paramAssoc]
+  }
+
+  buildRegExp(): [RegExp, ReplacementMap, ReplacementMap] {
+    let regexp = this.#root.buildRegExpStr()
+    if (regexp === '') {
+      return [/^$/, [], []] // never match
+    }
+
+    let captureIndex = 0
+    const indexReplacementMap: ReplacementMap = []
+    const paramReplacementMap: ReplacementMap = []
+
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (handlerIndex !== undefined) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex)
+        return '$()'
+      }
+      if (paramIndex !== undefined) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex
+        return ''
+      }
+
+      return ''
+    })
+
+    return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap]
+  }
+}

package/plugins/acryl-router/src/core/router/smart-router/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * SmartRouter for App.
+ */
+
+export { SmartRouter } from './router.ts'

package/plugins/acryl-router/src/core/router/smart-router/router.test.ts

@@ -0,0 +1,13 @@
+import { runTest } from '../common.case.test.ts'
+import { RegExpRouter } from '../reg-exp-router/index.ts'
+import { TrieRouter } from '../trie-router/index.ts'
+import { SmartRouter } from './router.ts'
+
+describe('SmartRouter', () => {
+  runTest({
+    newRouter: () =>
+      new SmartRouter({
+        routers: [new RegExpRouter(), new TrieRouter()],
+      }),
+  })
+})

package/plugins/acryl-router/src/core/router/smart-router/router.ts

@@ -0,0 +1,70 @@
+import type { Result, Router } from '../../router.ts'
+import { MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError } from '../../router.ts'
+
+export class SmartRouter<T> implements Router<T> {
+  name: string = 'SmartRouter'
+  #routers: Router<T>[] = []
+  #routes?: [string, string, T][] = []
+
+  constructor(init: { routers: Router<T>[] }) {
+    this.#routers = init.routers
+  }
+
+  add(method: string, path: string, handler: T) {
+    if (!this.#routes) {
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT)
+    }
+
+    this.#routes.push([method, path, handler])
+  }
+
+  match(method: string, path: string): Result<T> {
+    if (!this.#routes) {
+      throw new Error('Fatal error')
+    }
+
+    const routers = this.#routers
+    const routes = this.#routes
+
+    const len = routers.length
+    let i = 0
+    let res
+    for (; i < len; i++) {
+      const router = routers[i]
+      try {
+        for (let i = 0, len = routes.length; i < len; i++) {
+          router.add(...routes[i])
+        }
+        res = router.match(method, path)
+      } catch (e) {
+        if (e instanceof UnsupportedPathError) {
+          continue
+        }
+        throw e
+      }
+
+      this.match = router.match.bind(router)
+      this.#routers = [router]
+      this.#routes = undefined
+      break
+    }
+
+    if (i === len) {
+      // not found
+      throw new Error('Fatal error')
+    }
+
+    // e.g. "SmartRouter + RegExpRouter"
+    this.name = `SmartRouter + ${this.activeRouter.name}`
+
+    return res as Result<T>
+  }
+
+  get activeRouter(): Router<T> {
+    if (this.#routes || this.#routers.length !== 1) {
+      throw new Error('No active router has been determined yet.')
+    }
+
+    return this.#routers[0]
+  }
+}

package/plugins/acryl-router/src/core/router/trie-router/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * TrieRouter for App.
+ */
+
+export { TrieRouter } from './router.ts'