acrylblends 0.3.0 → 0.4.0

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

@@ -0,0 +1,154 @@
+import { METHOD_NAME_ALL } from '../../router.ts'
+import { runTest } from '../common.case.test.ts'
+import { buildInitParams, serializeInitParams, PreparedRegExpRouter } from './prepared-router.ts'
+
+describe('PreparedRegExpRouter', async () => {
+  runTest({
+    skip: [
+      {
+        reason: 'UnsupportedPath',
+        tests: [
+          'Duplicate param name > parent',
+          'Duplicate param name > child',
+          'Capture Group > Complex capturing group > GET request',
+          'Capture complex multiple directories > GET /part1/middle-b/latest',
+          'Capture complex multiple directories > GET /part1/middle-b/end-c/latest',
+          'Complex > Parameter with {.*} regexp',
+        ],
+      },
+      {
+        reason:
+          'This route can not be added with `:label` to PreparedRegExpRouter. This is ambiguous',
+        tests: ['Including slashes > GET /js/main.js'],
+      },
+    ],
+    newRouter: <T>() => {
+      let router: PreparedRegExpRouter<T>
+      const routes: [string, string, T][] = []
+      return {
+        name: 'PreparedRegExpRouterBuilder',
+        add: (method: string, path: string, handler: T) => {
+          routes.push([method, path, handler])
+        },
+        match: (method: string, path: string) => {
+          if (!router) {
+            const serialized = serializeInitParams(
+              buildInitParams({
+                paths: routes.map((r) => r[1]),
+              })
+            )
+            const params = eval(serialized) as ConstructorParameters<typeof PreparedRegExpRouter<T>>
+            router = new PreparedRegExpRouter<T>(...params)
+
+            for (const route of routes) {
+              router.add(...route)
+            }
+          }
+          return router.match(method, path)
+        },
+      }
+    },
+  })
+
+  describe('add()', () => {
+    it('should add a route', () => {
+      const params = buildInitParams({
+        paths: ['/hello'],
+      })
+      const router = new PreparedRegExpRouter(...params)
+      router.add('GET', '/hello', 'get hello')
+      expect(router.match('GET', '/hello')).toEqual([[['get hello', {}]], []])
+    })
+
+    it('should throw an error if the path is not pre-registered', () => {
+      const params = buildInitParams({
+        paths: ['/hello'],
+      })
+      const router = new PreparedRegExpRouter(...params)
+      expect(() => router.add('GET', '/unknown', 'get hello')).toThrowError()
+    })
+  })
+})
+
+describe('buildInitParams() and serializeInitParams()', () => {
+  it('should build empty init params', () => {
+    const params = buildInitParams({
+      paths: [],
+    })
+    expect(params).toEqual([{ [METHOD_NAME_ALL]: [/^$/, [], {}] }, {}])
+    expect((0, eval)(serializeInitParams(params))).toEqual(params)
+  })
+
+  it('should build init params with one static path', () => {
+    const params = buildInitParams({
+      paths: ['/hello'],
+    })
+    expect(params).toEqual([
+      {
+        [METHOD_NAME_ALL]: [
+          /^$/,
+          [],
+          {
+            '/hello': [[], []],
+          },
+        ],
+      },
+      {
+        '/hello': [[['']]],
+      },
+    ])
+    expect((0, eval)(serializeInitParams(params))).toEqual(params)
+  })
+
+  it('should build init params with paths with params', () => {
+    const params = buildInitParams({
+      paths: ['/hello/:name', '/hello/:name/posts/:postId'],
+    })
+    expect(params).toEqual([
+      {
+        [METHOD_NAME_ALL]: [/^\/hello\/([^/]+)(?:$()|\/posts\/([^/]+)$())/, [0, 0, [], 0, []], {}],
+      },
+      {
+        '/hello/:name': [[[2], { name: 1 }]],
+        '/hello/:name/posts/:postId': [[[4], { name: 1, postId: 3 }]],
+      },
+    ])
+    expect((0, eval)(serializeInitParams(params))).toEqual(params)
+  })
+
+  it('should build init params with wildcard', () => {
+    const params = buildInitParams({
+      paths: ['*'],
+    })
+    expect(params).toEqual([
+      {
+        [METHOD_NAME_ALL]: [/^.*$()/, [0, []], {}],
+      },
+      {},
+    ])
+    expect((0, eval)(serializeInitParams(params))).toEqual(params)
+  })
+
+  it('should build init params with complex path', () => {
+    const params = buildInitParams({
+      paths: ['/hello', '/hello/:name', '/hello/:name/posts/:postId', '*'],
+    })
+    expect(params).toEqual([
+      {
+        [METHOD_NAME_ALL]: [
+          /^(?:\/hello\/([^/]+)(?:$()|\/posts\/([^/]+)$())|.*$())/,
+          [0, 0, [], 0, [], []],
+          {
+            '/hello': [[], []],
+          },
+        ],
+      },
+      {
+        '/hello': [[['']]],
+        '/hello/:name': [[[2], { name: 1 }]],
+        '/hello/:name/posts/:postId': [[[4], { name: 1, postId: 3 }]],
+      },
+    ])
+    expect((0, eval)(serializeInitParams(params))).toEqual(params)
+  })
+})

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

@@ -0,0 +1,165 @@
+import type { ParamIndexMap, Result, Router } from '../../router.ts'
+import { METHOD_NAME_ALL } from '../../router.ts'
+import type { HandlerData, Matcher, MatcherMap, StaticMap } from './matcher.ts'
+import { match, emptyParam } from './matcher.ts'
+import { RegExpRouter } from './router.ts'
+
+type RelocateMap = Record<string, ([(number | string)[], ParamIndexMap] | [(number | string)[]])[]>
+
+export class PreparedRegExpRouter<T> implements Router<T> {
+  name: string = 'PreparedRegExpRouter'
+  #matchers: MatcherMap<T>
+  #relocateMap: RelocateMap
+
+  constructor(matchers: MatcherMap<T>, relocateMap: RelocateMap) {
+    this.#matchers = matchers
+    this.#relocateMap = relocateMap
+  }
+
+  #addWildcard(method: string, handlerData: [T, ParamIndexMap]) {
+    const matcher = this.#matchers[method] as Matcher<T>
+    matcher[1].forEach((list) => list && list.push(handlerData))
+    Object.values(matcher[2]).forEach((list) => (list[0] as [T, ParamIndexMap][]).push(handlerData))
+  }
+
+  #addPath(
+    method: string,
+    path: string,
+    handler: T,
+    indexes: (number | string)[],
+    map: ParamIndexMap | undefined
+  ) {
+    const matcher = this.#matchers[method] as Matcher<T>
+    if (!map) {
+      // assumed to be a static route
+      matcher[2][path][0].push([handler, {}])
+    } else {
+      indexes.forEach((index) => {
+        if (typeof index === 'number') {
+          matcher[1][index].push([handler, map])
+        } else {
+          ;(matcher[2][index || path][0] as [T, ParamIndexMap][]).push([handler, map])
+        }
+      })
+    }
+  }
+
+  add(method: string, path: string, handler: T) {
+    if (!this.#matchers[method]) {
+      const all = this.#matchers[METHOD_NAME_ALL] as Matcher<T>
+      const staticMap = {} as StaticMap<T>
+      for (const key in all[2]) {
+        staticMap[key] = [all[2][key][0].slice(), emptyParam] as Result<T>
+      }
+      this.#matchers[method] = [
+        all[0],
+        all[1].map((list) => (Array.isArray(list) ? list.slice() : 0)) as HandlerData<T>[],
+        staticMap,
+      ]
+    }
+
+    if (path === '/*' || path === '*') {
+      const handlerData: [T, ParamIndexMap] = [handler, {}]
+      if (method === METHOD_NAME_ALL) {
+        for (const m in this.#matchers) {
+          this.#addWildcard(m, handlerData)
+        }
+      } else {
+        this.#addWildcard(method, handlerData)
+      }
+      return
+    }
+
+    const data = this.#relocateMap[path]
+    if (!data) {
+      throw new Error(`Path ${path} is not registered`)
+    }
+    for (const [indexes, map] of data) {
+      if (method === METHOD_NAME_ALL) {
+        for (const m in this.#matchers) {
+          this.#addPath(m, path, handler, indexes, map)
+        }
+      } else {
+        this.#addPath(method, path, handler, indexes, map)
+      }
+    }
+  }
+
+  protected buildAllMatchers(): MatcherMap<T> {
+    return this.#matchers
+  }
+
+  match: typeof match<Router<T>, T> = match
+}
+
+export const buildInitParams: (params: {
+  paths: string[]
+}) => ConstructorParameters<typeof PreparedRegExpRouter> = ({ paths }) => {
+  const RegExpRouterWithMatcherExport = class<T> extends RegExpRouter<T> {
+    buildAndExportAllMatchers() {
+      return this.buildAllMatchers()
+    }
+  }
+  const router = new RegExpRouterWithMatcherExport<string>()
+  for (const path of paths) {
+    router.add(METHOD_NAME_ALL, path, path)
+  }
+
+  const matchers = router.buildAndExportAllMatchers()
+  const all = matchers[METHOD_NAME_ALL] as Matcher<string>
+
+  const relocateMap: RelocateMap = {}
+  for (const path of paths) {
+    if (path === '/*' || path === '*') {
+      continue
+    }
+    all[1].forEach((list, i) => {
+      list.forEach(([p, map]) => {
+        if (p === path) {
+          if (relocateMap[path]) {
+            relocateMap[path][0][1] = {
+              ...relocateMap[path][0][1],
+              ...map,
+            }
+          } else {
+            relocateMap[path] = [[[], map]]
+          }
+          if (relocateMap[path][0][0].findIndex((j) => j === i) === -1) {
+            relocateMap[path][0][0].push(i)
+          }
+        }
+      })
+    })
+    for (const path2 in all[2]) {
+      all[2][path2][0].forEach(([p]) => {
+        if (p === path) {
+          relocateMap[path] ||= [[[]]]
+          const value = path2 === path ? '' : path2
+          if (relocateMap[path][0][0].findIndex((v) => v === value) === -1) {
+            relocateMap[path][0][0].push(value)
+          }
+        }
+      })
+    }
+  }
+
+  for (let i = 0, len = all[1].length; i < len; i++) {
+    all[1][i] = all[1][i] ? [] : (0 as unknown as HandlerData<string>)
+  }
+  for (const path in all[2]) {
+    all[2][path][0] = []
+  }
+
+  return [matchers, relocateMap]
+}
+
+export const serializeInitParams: (
+  params: ConstructorParameters<typeof PreparedRegExpRouter>
+) => string = ([matchers, relocateMap]) => {
+  // Embed the regular expression as a result of `toString()` so that it can be evaluated as JavaScript.
+  const matchersStr = JSON.stringify(matchers, (_, value) =>
+    value instanceof RegExp ? `##${value.toString()}##` : value
+  ).replace(/"##(.+?)##"/g, (_, str) => str.replace(/\\\\/g, '\\'))
+  const relocateMapStr = JSON.stringify(relocateMap)
+  return `[${matchersStr},${relocateMapStr}]`
+}

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

@@ -0,0 +1,265 @@
+import type { ParamIndexMap, ParamStash } from '../../router.ts'
+import { UnsupportedPathError } from '../../router.ts'
+import { runTest } from '../common.case.test.ts'
+import { RegExpRouter } from './router.ts'
+
+describe('RegExpRouter', () => {
+  runTest({
+    skip: [
+      {
+        reason: 'UnsupportedPath',
+        tests: [
+          'Duplicate param name > parent',
+          'Duplicate param name > child',
+          'Capture Group > Complex capturing group > GET request',
+          'Capture complex multiple directories > GET /part1/middle-b/latest',
+          'Capture complex multiple directories > GET /part1/middle-b/end-c/latest',
+          'Complex > Parameter with {.*} regexp',
+        ],
+      },
+      {
+        reason: 'This route can not be added with `:label` to RegExpRouter. This is ambiguous',
+        tests: ['Including slashes > GET /js/main.js'],
+      },
+    ],
+    newRouter: () => new RegExpRouter(),
+  })
+
+  describe('Return value type', () => {
+    it('Should return [[T, ParamIndexMap][], ParamStash]', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/posts/:id', 'get post')
+
+      const [res, stash] = router.match('GET', '/posts/1')
+      expect(res.length).toBe(1)
+      expect(res).toEqual([['get post', { id: 1 }]])
+      expect((stash as ParamStash)[1]).toBe('1')
+    })
+  })
+
+  describe('UnsupportedPathError', () => {
+    describe('Ambiguous', () => {
+      it('GET /entry/:name', () => {
+        const router = new RegExpRouter<string>()
+        router.add('GET', '/:user/entries', 'get user entries')
+        expect(() => {
+          router.add('GET', '/entry/:name', 'get entry')
+        }).toThrowError(UnsupportedPathError)
+      })
+    })
+
+    describe('Multiple handlers with different label', () => {
+      it('GET /:class/:id', () => {
+        const router = new RegExpRouter<string>()
+        router.add('GET', '/:type/:id', ':type')
+        expect(() => {
+          router.add('GET', '/:class/:id', ':class')
+        }).toThrowError(UnsupportedPathError)
+      })
+    })
+
+    it('parent', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/:id/:action', 'foo')
+      expect(() => {
+        router.add('GET', '/posts/:id', 'bar')
+      }).toThrowError(UnsupportedPathError)
+    })
+
+    it('child', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/posts/:id', 'foo')
+      expect(() => {
+        router.add('GET', '/:id/:action', 'bar')
+      }).toThrowError(UnsupportedPathError)
+    })
+
+    describe('static and dynamic', () => {
+      it('static first', () => {
+        const router = new RegExpRouter<string>()
+        router.add('GET', '/reg-exp/router', 'foo')
+        expect(() => {
+          router.add('GET', '/reg-exp/:id', 'bar')
+        }).toThrowError(UnsupportedPathError)
+      })
+
+      it('long label', () => {
+        const router = new RegExpRouter<string>()
+        router.add('GET', '/reg-exp/router', 'foo')
+        expect(() => {
+          router.add('GET', '/reg-exp/:service', 'bar')
+        }).toThrowError(UnsupportedPathError)
+      })
+
+      it('dynamic first', () => {
+        const router = new RegExpRouter<string>()
+        router.add('GET', '/reg-exp/:id', 'bar')
+        expect(() => {
+          router.add('GET', '/reg-exp/router', 'foo')
+        }).toThrowError(UnsupportedPathError)
+      })
+    })
+
+    it('different regular expression', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/:id/:action{create|update}', 'foo')
+      expect(() => {
+        router.add('GET', '/:id/:action{delete}', 'bar')
+      }).toThrowError(UnsupportedPathError)
+    })
+
+    it('ALL route added after a specific-method route', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/foo/:a', 'foo')
+      expect(() => {
+        router.add('ALL', '/foo/:b', 'bar')
+      }).toThrowError(UnsupportedPathError)
+    })
+
+    it('specific-method route added after an ALL route', () => {
+      const router = new RegExpRouter<string>()
+      router.add('ALL', '/reg-exp/router', 'foo')
+
+      expect(() => {
+        router.add('GET', '/reg-exp/:id', 'bar')
+      }).toThrowError(UnsupportedPathError)
+    })
+
+    it('different methods do not conflict', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/reg-exp/router', 'foo')
+      router.add('POST', '/reg-exp/:id', 'bar')
+
+      expect(router.match('GET', '/reg-exp/router')[0][0][0]).toBe('foo')
+      expect(router.match('POST', '/reg-exp/router')[0][0][0]).toBe('bar')
+    })
+
+    describe('Capture Group', () => {
+      describe('Complex capturing group', () => {
+        it('GET request', () => {
+          const router = new RegExpRouter<string>()
+          expect(() => {
+            router.add('GET', '/foo/:capture{ba(r|z)}', 'ok')
+          }).toThrowError(UnsupportedPathError)
+        })
+      })
+    })
+  })
+
+  describe('Wildcard after label', () => {
+    it('Should be able to add a tail wildcard after a label', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/api/:x', 'label')
+      router.add('GET', '/api/*', 'wildcard')
+
+      const [res] = router.match('GET', '/api/foo')
+      expect(res.length).toBe(2)
+      expect(res[0][0]).toBe('label')
+      expect(res[1][0]).toBe('wildcard')
+    })
+
+    it('Should prioritize the only wildcard over the tail wildcard regardless of the order', () => {
+      for (const paths of [
+        ['/a*', '/a/*'],
+        ['/a/*', '/a*'],
+      ]) {
+        const router = new RegExpRouter<string>()
+        for (const path of paths) {
+          router.add('GET', path, path)
+        }
+        const [res] = router.match('GET', '/a')
+        expect(res[0][0]).toBe('/a*')
+      }
+    })
+  })
+
+  describe('Single character regexp pattern', () => {
+    it('Should capture a param even if a static path created the node first', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/a/c', 'static')
+      router.add('GET', '/:x{a}/b', 'pattern')
+
+      const [res, stash] = router.match('GET', '/a/b')
+      expect(res.length).toBe(1)
+      expect(res[0][0]).toBe('pattern')
+      expect((stash as ParamStash)[(res[0][1] as ParamIndexMap)['x']]).toBe('a')
+    })
+
+    it('Should throw an error when a pattern terminal conflicts with a static terminal', () => {
+      for (const paths of [
+        ['/a', '/:x{a}'],
+        ['/:x{a}', '/a'],
+      ]) {
+        const router = new RegExpRouter<string>()
+        router.add('GET', paths[0], paths[0])
+        expect(() => {
+          router.add('GET', paths[1], paths[1])
+        }).toThrowError(UnsupportedPathError)
+      }
+    })
+
+    it('Should coexist with static paths regardless of the order', () => {
+      for (const paths of [
+        ['/foo/bar', '/:y{b}'],
+        ['/:y{b}', '/foo/bar'],
+      ]) {
+        const router = new RegExpRouter<string>()
+        for (const path of paths) {
+          router.add('GET', path, path)
+        }
+        expect(router.match('GET', '/foo/bar')[0][0][0]).toBe('/foo/bar')
+        expect(router.match('GET', '/b')[0][0][0]).toBe('/:y{b}')
+      }
+    })
+
+    it('Should coexist with dynamic paths regardless of the order', () => {
+      for (const paths of [
+        ['/foo/:p', '/:x{a}'],
+        ['/:x{a}', '/foo/:p'],
+      ]) {
+        const router = new RegExpRouter<string>()
+        for (const path of paths) {
+          router.add('GET', path, path)
+        }
+        expect(router.match('GET', '/a')[0][0][0]).toBe('/:x{a}')
+        expect(router.match('GET', '/foo/v')[0][0][0]).toBe('/foo/:p')
+      }
+    })
+
+    it('Should throw an error for a single meta character pattern', () => {
+      const router = new RegExpRouter<string>()
+      expect(() => {
+        router.add('GET', '/:x{.}', 'meta')
+      }).toThrowError(UnsupportedPathError)
+    })
+  })
+
+  describe('Capture a param of a label node created by a middle wildcard', () => {
+    it('Should capture the param', () => {
+      const router = new RegExpRouter<string>()
+      router.add('GET', '/w/*/x', 'wildcard')
+      router.add('GET', '/w/:id/y', 'label')
+
+      const [res, stash] = router.match('GET', '/w/123/y')
+      expect(res.length).toBe(1)
+      expect(res[0][0]).toBe('label')
+      expect((stash as ParamStash)[(res[0][1] as ParamIndexMap)['id']]).toBe('123')
+    })
+  })
+
+  describe('Static path including a colon in the middle', () => {
+    it('Should be treated as a static path', () => {
+      for (const paths of [
+        ['/v1/name:activate', '/v1/name2'],
+        ['/v1/name2', '/v1/name:activate'],
+      ]) {
+        const router = new RegExpRouter<string>()
+        for (const path of paths) {
+          router.add('GET', path, path)
+        }
+        expect(router.match('GET', '/v1/name:activate')[0][0][0]).toBe('/v1/name:activate')
+        expect(router.match('GET', '/v1/name2')[0][0][0]).toBe('/v1/name2')
+      }
+    })
+  })
+})