acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-router/src/core/helper/route/index.test.ts

@@ -0,0 +1,259 @@
+import { matchedRoutes, routePath, baseRoutePath, basePath } from './index.ts'
+import { Context } from '../../context.ts'
+import { App } from '../../app.ts'
+
+const defaultContextOptions = {
+  executionCtx: {
+    waitUntil: () => {},
+    passThroughOnException: () => {},
+    props: {},
+  },
+  env: {},
+}
+
+describe('matchedRoutes', () => {
+  it('should return matched routes', () => {
+    const handlerA = () => {}
+    const handlerB = () => {}
+    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
+    const c = new Context(rawRequest, {
+      path: '/123/key',
+      matchResult: [
+        [
+          [
+            [handlerA, { basePath: '/', handler: handlerA, method: 'GET', path: '/:id' }],
+            { id: '123' },
+          ],
+          [
+            [handlerA, { basePath: '/', handler: handlerB, method: 'GET', path: '/:id/:name' }],
+            { id: '456', name: 'key' },
+          ],
+        ],
+      ],
+      ...defaultContextOptions,
+    })
+
+    expect(matchedRoutes(c)).toEqual([
+      { basePath: '/', handler: handlerA, method: 'GET', path: '/:id' },
+      { basePath: '/', handler: handlerB, method: 'GET', path: '/:id/:name' },
+    ])
+  })
+})
+
+describe('routePath', () => {
+  it('should return route path', () => {
+    const handlerA = () => {}
+    const handlerB = () => {}
+    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
+    const c = new Context(rawRequest, {
+      path: '/123/key',
+      matchResult: [
+        [
+          [
+            [handlerA, { basePath: '/', handler: handlerA, method: 'GET', path: '/:id' }],
+            { id: '123' },
+          ],
+          [
+            [handlerA, { basePath: '/', handler: handlerB, method: 'GET', path: '/:id/:name' }],
+            { id: '456', name: 'key' },
+          ],
+        ],
+      ],
+      ...defaultContextOptions,
+    })
+
+    expect(routePath(c)).toBe('/:id')
+
+    expect(routePath(c, 0)).toBe('/:id')
+    expect(routePath(c, 1)).toBe('/:id/:name')
+    expect(routePath(c, -1)).toBe('/:id/:name')
+    expect(routePath(c, 2)).toBe('')
+
+    c.req.routeIndex = 1
+    expect(routePath(c)).toBe('/:id/:name')
+  })
+})
+
+describe('baseRoutePath', () => {
+  it('should return raw basePath', () => {
+    const handlerA = () => {}
+    const handlerB = () => {}
+    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
+    const c = new Context(rawRequest, {
+      path: '/123/key',
+      matchResult: [
+        [
+          [
+            [handlerA, { basePath: '/', handler: handlerA, method: 'GET', path: '/:id' }],
+            { id: '123' },
+          ],
+          [
+            [handlerA, { basePath: '/sub', handler: handlerB, method: 'GET', path: '/:id/:name' }],
+            { id: '456', name: 'key' },
+          ],
+          [
+            [handlerA, { basePath: '/:sub', handler: handlerB, method: 'GET', path: '/:id/:name' }],
+            { id: '456', name: 'key' },
+          ],
+        ],
+      ],
+      ...defaultContextOptions,
+    })
+
+    expect(baseRoutePath(c)).toBe('/')
+
+    expect(baseRoutePath(c, 0)).toBe('/')
+    expect(baseRoutePath(c, 1)).toBe('/sub')
+    expect(baseRoutePath(c, 2)).toBe('/:sub')
+    expect(baseRoutePath(c, -1)).toBe('/:sub')
+    expect(baseRoutePath(c, 3)).toBe('')
+
+    c.req.routeIndex = 1
+    expect(baseRoutePath(c)).toBe('/sub')
+
+    c.req.routeIndex = 2
+    expect(baseRoutePath(c)).toBe('/:sub')
+  })
+})
+
+describe('basePath', () => {
+  it('should return basePath without parameters', () => {
+    const handlerA = () => {}
+    const handlerB = () => {}
+    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
+    const c = new Context(rawRequest, {
+      path: '/123/key',
+      matchResult: [
+        [
+          [
+            [handlerA, { basePath: '/', handler: handlerA, method: 'GET', path: '/:id' }],
+            { id: '123' },
+          ],
+          [
+            [handlerA, { basePath: '/sub', handler: handlerB, method: 'GET', path: '/:id/:name' }],
+            { id: '456', name: 'key' },
+          ],
+        ],
+      ],
+      ...defaultContextOptions,
+    })
+
+    expect(basePath(c)).toBe('/')
+    expect(basePath(c)).toBe('/') // cached value
+
+    expect(basePath(c, 0)).toBe('/')
+    expect(basePath(c, 1)).toBe('/sub')
+    expect(basePath(c, -1)).toBe('/sub')
+    expect(basePath(c, 2)).toBe('')
+
+    c.req.routeIndex = 1
+    expect(basePath(c)).toBe('/sub')
+  })
+
+  it('should return basePath with embedded parameters', () => {
+    const handlerA = () => {}
+    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
+    const c = new Context(rawRequest, {
+      path: '/sub-app-path/123/key',
+      matchResult: [
+        [
+          [
+            [handlerA, { basePath: '/:sub', handler: handlerA, method: 'GET', path: '/:id' }],
+            { id: '123' },
+          ],
+        ],
+      ],
+      ...defaultContextOptions,
+    })
+
+    expect(basePath(c)).toBe('/sub-app-path')
+  })
+
+  it('should return basePath with wildcard', () => {
+    const handlerA = () => {}
+    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
+    const c = new Context(rawRequest, {
+      path: '/sub-app-path/foo/app/123/key',
+      matchResult: [
+        [
+          [
+            [
+              handlerA,
+              { basePath: '/sub-app-path/*/app', handler: handlerA, method: 'GET', path: '/:id' },
+            ],
+            { id: '123' },
+          ],
+        ],
+      ],
+      ...defaultContextOptions,
+    })
+
+    expect(basePath(c)).toBe('/sub-app-path/foo/app')
+  })
+
+  it('should return the fully expanded basePath for nested route() apps', async () => {
+    const app = new App()
+    const sub1 = new App()
+    const sub2 = new App()
+    const sub3 = new App()
+
+    sub3.get('/assets/*', (c) => c.json({ baseRoutePath: baseRoutePath(c), basePath: basePath(c) }))
+    sub2.route('/:app/sub3/assets', sub3)
+    sub1.route('/:app/sub2/assets', sub2)
+    app.route('/:app/sub1/assets', sub1)
+
+    const res = await app.request(
+      '/s1/sub1/assets/ss2/sub2/assets/sss3/sub3/assets/assets/file-hoge/assets-kage.js'
+    )
+    expect(await res.json()).toEqual({
+      baseRoutePath: '/:app/sub1/assets/:app/sub2/assets/:app/sub3/assets',
+      basePath: '/s1/sub1/assets/ss2/sub2/assets/sss3/sub3/assets',
+    })
+  })
+
+  it('should return basePath with custom regex pattern', () => {
+    const handlerA = () => {}
+    const rawRequest = new Request('http://localhost?page=2&tag=A&tag=B')
+    const c = new Context(rawRequest, {
+      path: '/sub-app-path/foo/123/key',
+      matchResult: [
+        [
+          [
+            [
+              handlerA,
+              {
+                basePath: '/sub-app-path/:sub{foo|bar}',
+                handler: handlerA,
+                method: 'GET',
+                path: '/:id',
+              },
+            ],
+            { sub: 'foo', id: '123' },
+          ],
+        ],
+      ],
+      ...defaultContextOptions,
+    })
+
+    expect(basePath(c)).toBe('/sub-app-path/foo')
+  })
+
+  it('should return basePath with custom regex pattern mounted with app.route()', async () => {
+    const app = new App()
+    const subApp = new App()
+
+    subApp.get('/posts/:id', (c) => c.text(basePath(c)))
+    app.route('/api/:version{v[0-9]+}', subApp)
+    app.route('/tags/:tag{foo|bar}', subApp)
+    app.route('/users/:name{[a-z]+}/:group', subApp)
+
+    let res = await app.request('/api/v2/posts/123')
+    expect(await res.text()).toBe('/api/v2')
+
+    res = await app.request('/tags/bar/posts/123')
+    expect(await res.text()).toBe('/tags/bar')
+
+    res = await app.request('/users/abc/def/posts/123')
+    expect(await res.text()).toBe('/users/abc/def')
+  })
+})

package/plugins/acryl-router/src/core/helper/route/index.ts

@@ -0,0 +1,144 @@
+import type { Context } from '../../context.ts'
+import { GET_MATCH_RESULT } from '../../request/constants.ts'
+import type { RouterRoute } from '../../types.ts'
+import { getPattern, splitRoutingPath } from '../../utils/url.ts'
+
+/**
+ * Get matched routes in the handler
+ *
+ * @param {Context} c - The context object
+ * @returns An array of matched routes
+ *
+ * @example
+ * ```ts
+ * import { matchedRoutes } from 'acryl-router/helpers'
+ *
+ * app.use('*', async function logger(c, next) {
+ *   await next()
+ *   matchedRoutes(c).forEach(({ handler, method, path }, i) => {
+ *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+ *     console.log(
+ *       method,
+ *       ' ',
+ *       path,
+ *       ' '.repeat(Math.max(10 - path.length, 0)),
+ *       name,
+ *       i === c.req.routeIndex ? '<- respond from here' : ''
+ *     )
+ *   })
+ * })
+ * ```
+ */
+export const matchedRoutes = (c: Context): RouterRoute[] =>
+  // @ts-expect-error c.req[GET_MATCH_RESULT] is not typed
+  (c.req as unknown)[GET_MATCH_RESULT][0].map(([[, route]]) => route)
+
+/**
+ * Get the route path registered within the handler
+ *
+ * @param {Context} c - The context object
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+ * @returns The route path registered within the handler
+ *
+ * @example
+ * ```ts
+ * import { routePath } from 'acryl-router/helpers'
+ *
+ * app.use('*', (c, next) => {
+ *   console.log(routePath(c)) // '*'
+ *   console.log(routePath(c, -1)) // '/posts/:id'
+ *   return next()
+ * })
+ *
+ * app.get('/posts/:id', (c) => {
+ *   return c.text(routePath(c)) // '/posts/:id'
+ * })
+ * ```
+ */
+export const routePath = (c: Context, index?: number): string =>
+  matchedRoutes(c).at(index ?? c.req.routeIndex)?.path ?? ''
+
+/**
+ * Get the basePath of the as-is route specified by routing.
+ *
+ * @param {Context} c - The context object
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+ * @returns The basePath of the as-is route specified by routing.
+ *
+ * @example
+ * ```ts
+ * import { baseRoutePath } from 'acryl-router/helpers'
+ *
+ * const app = new App()
+ *
+ * const subApp = new App()
+ * subApp.get('/posts/:id', (c) => {
+ *   return c.text(baseRoutePath(c)) // '/:sub'
+ * })
+ *
+ * app.route('/:sub', subApp)
+ * ```
+ */
+export const baseRoutePath = (c: Context, index?: number): string =>
+  matchedRoutes(c).at(index ?? c.req.routeIndex)?.basePath ?? ''
+
+/**
+ * Get the basePath with embedded parameters
+ *
+ * @param {Context} c - The context object
+ * @param {number} index - The index of the route from which to retrieve the path, similar to Array.prototype.at(), where a negative number is the index counted from the end of the matching route. Defaults to the current route index.
+ * @returns The basePath with embedded parameters.
+ *
+ * @example
+ * ```ts
+ * import { basePath } from 'acryl-router/helpers'
+ *
+ * const app = new App()
+ *
+ * const subApp = new App()
+ * subApp.get('/posts/:id', (c) => {
+ *   return c.text(basePath(c)) // '/requested-sub-app-path'
+ * })
+ *
+ * app.route('/:sub', subApp)
+ * ```
+ */
+const basePathCacheMap: WeakMap<Context, Record<number, string>> = new WeakMap()
+export const basePath = (c: Context, index?: number): string => {
+  index ??= c.req.routeIndex
+
+  const cache = basePathCacheMap.get(c) || []
+  if (typeof cache[index] === 'string') {
+    return cache[index]
+  }
+
+  let result: string
+  const rp = baseRoutePath(c, index)
+  if (!/[:*]/.test(rp)) {
+    result = rp
+  } else {
+    const paths = splitRoutingPath(rp)
+
+    const reqPath = c.req.path
+    let basePathLength = 0
+    for (let i = 0, len = paths.length; i < len; i++) {
+      const pattern = getPattern(paths[i], paths[i + 1])
+      if (pattern) {
+        const re = pattern[2] === true || pattern === '*' ? /[^\/]+/ : pattern[2]
+        const restPath = reqPath.substring(basePathLength + 1)
+        // like the router, fall back to matching only the current segment
+        const segment = restPath.split('/', 1)[0]
+        basePathLength += (restPath.match(re)?.[0] ?? (re.test(segment) ? segment : '')).length
+      } else {
+        basePathLength += paths[i].length
+      }
+      basePathLength += 1 // for '/'
+    }
+    result = reqPath.substring(0, basePathLength)
+  }
+
+  cache[index] = result
+  basePathCacheMap.set(c, cache)
+
+  return result
+}

package/plugins/acryl-router/src/core/helper/streaming/index.ts

@@ -0,0 +1,9 @@
+/**
+ * @module
+ * Streaming Helper for App.
+ */
+
+export { stream } from './stream.ts'
+export type { SSEMessage } from './sse.ts'
+export { streamSSE, SSEStreamingApi } from './sse.ts'
+export { streamText } from './text.ts'

package/plugins/acryl-router/src/core/helper/streaming/sse.ts

@@ -0,0 +1,101 @@
+import type { Context } from '../../context.ts'
+import { HtmlEscapedCallbackPhase, resolveCallback } from '../../utils/html.ts'
+import { StreamingApi } from '../../utils/stream.ts'
+import { isOldBunVersion } from './utils.ts'
+
+export interface SSEMessage {
+  data: string | Promise<string>
+  event?: string
+  id?: string
+  retry?: number
+}
+
+export class SSEStreamingApi extends StreamingApi {
+  constructor(writable: WritableStream, readable: ReadableStream) {
+    super(writable, readable)
+  }
+
+  async writeSSE(message: SSEMessage) {
+    const data = await resolveCallback(message.data, HtmlEscapedCallbackPhase.Stringify, false, {})
+    const dataLines = (data as string)
+      .split(/\r\n|\r|\n/)
+      .map((line) => {
+        return `data: ${line}`
+      })
+      .join('\n')
+
+    for (const key of ['event', 'id'] as const) {
+      const value = message[key]
+      if (value && /[\r\n]/.test(value)) {
+        throw new Error(`${key} must not contain "\\r" or "\\n"`)
+      }
+    }
+
+    const sseData =
+      [
+        message.event && `event: ${message.event}`,
+        dataLines,
+        message.id !== undefined && `id: ${message.id}`,
+        message.retry !== undefined && `retry: ${message.retry}`,
+      ]
+        .filter(Boolean)
+        .join('\n') + '\n\n'
+
+    await this.write(sseData)
+  }
+}
+
+const run = async (
+  stream: SSEStreamingApi,
+  cb: (stream: SSEStreamingApi) => Promise<void>,
+  onError?: (e: Error, stream: SSEStreamingApi) => Promise<void>
+): Promise<void> => {
+  try {
+    await cb(stream)
+  } catch (e) {
+    if (e instanceof Error && onError) {
+      await onError(e, stream)
+
+      await stream.writeSSE({
+        event: 'error',
+        data: e.message,
+      })
+    } else {
+      console.error(e)
+    }
+  } finally {
+    stream.close()
+  }
+}
+
+const contextStash: WeakMap<ReadableStream, Context> = new WeakMap<ReadableStream, Context>()
+
+export const streamSSE = (
+  c: Context,
+  cb: (stream: SSEStreamingApi) => Promise<void>,
+  onError?: (e: Error, stream: SSEStreamingApi) => Promise<void>
+): Response => {
+  const { readable, writable } = new TransformStream()
+  const stream = new SSEStreamingApi(writable, readable)
+
+  // Until Bun v1.1.27, Bun didn't call cancel() on the ReadableStream for Response objects from Bun.serve()
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener('abort', () => {
+      if (!stream.closed) {
+        stream.abort()
+      }
+    })
+  }
+
+  // in bun, `c` is destroyed when the request is returned, so hold it until the end of streaming
+  contextStash.set(stream.responseReadable, c)
+
+  c.header('Transfer-Encoding', 'chunked')
+  c.header('Content-Type', 'text/event-stream')
+  c.header('Cache-Control', 'no-cache')
+  c.header('Connection', 'keep-alive')
+
+  run(stream, cb, onError)
+
+  return c.newResponse(stream.responseReadable)
+}

package/plugins/acryl-router/src/core/helper/streaming/stream.test.ts

@@ -0,0 +1,128 @@
+import { stream } from './index.ts'
+import { Context } from '../../context.ts'
+
+describe('Basic Streaming Helper', () => {
+  const req = new Request('http://localhost/')
+  let c: Context
+  beforeEach(() => {
+    c = new Context(req)
+  })
+
+  it('Check stream Response', async () => {
+    const res = stream(c, async (stream) => {
+      for (let i = 0; i < 3; i++) {
+        await stream.write(new Uint8Array([i]))
+        await stream.sleep(1)
+      }
+    })
+    if (!res.body) {
+      throw new Error('Body is null')
+    }
+    const reader = res.body.getReader()
+    for (let i = 0; i < 3; i++) {
+      const { value } = await reader.read()
+      expect(value).toEqual(new Uint8Array([i]))
+    }
+  })
+
+  it('Check stream Response if aborted by client', async () => {
+    let aborted = false
+    const res = stream(c, async (stream) => {
+      stream.onAbort(() => {
+        aborted = true
+      })
+      for (let i = 0; i < 3; i++) {
+        await stream.write(new Uint8Array([i]))
+        await stream.sleep(1)
+      }
+    })
+    if (!res.body) {
+      throw new Error('Body is null')
+    }
+    const reader = res.body.getReader()
+    const { value } = await reader.read()
+    expect(value).toEqual(new Uint8Array([0]))
+    reader.cancel()
+    expect(aborted).toBeTruthy()
+  })
+
+  it('Check stream Response if aborted by abort signal', async () => {
+    // Emulate an old version of Bun (version 1.1.0) for this specific test case
+    // @ts-expect-error Bun is not typed
+    global.Bun = {
+      version: '1.1.0',
+    }
+    const ac = new AbortController()
+    const req = new Request('http://localhost/', { signal: ac.signal })
+    const c = new Context(req)
+
+    let aborted = false
+    const res = stream(c, async (stream) => {
+      stream.onAbort(() => {
+        aborted = true
+      })
+      for (let i = 0; i < 3; i++) {
+        await stream.write(new Uint8Array([i]))
+        await stream.sleep(1)
+      }
+    })
+    if (!res.body) {
+      throw new Error('Body is null')
+    }
+    const reader = res.body.getReader()
+    const { value } = await reader.read()
+    expect(value).toEqual(new Uint8Array([0]))
+    ac.abort()
+    expect(aborted).toBeTruthy()
+    // @ts-expect-error Bun is not typed
+    delete global.Bun
+  })
+
+  it('Check stream Response if pipe is aborted by abort signal', async () => {
+    // Emulate an old version of Bun (version 1.1.0) for this specific test case
+    // @ts-expect-error Bun is not typed
+    global.Bun = {
+      version: '1.1.0',
+    }
+    const ac = new AbortController()
+    const req = new Request('http://localhost/', { signal: ac.signal })
+    const c = new Context(req)
+
+    let aborted = false
+    const res = stream(c, async (stream) => {
+      stream.onAbort(() => {
+        aborted = true
+      })
+      await stream.pipe(new ReadableStream())
+    })
+    if (!res.body) {
+      throw new Error('Body is null')
+    }
+    const reader = res.body.getReader()
+    const pReading = reader.read()
+    ac.abort()
+    await pReading
+    expect(aborted).toBeTruthy()
+    // @ts-expect-error Bun is not typed
+    delete global.Bun
+  })
+
+  it('Check stream Response if error occurred', async () => {
+    const onError = vi.fn()
+    const res = stream(
+      c,
+      async () => {
+        throw new Error('error')
+      },
+      onError
+    )
+    if (!res.body) {
+      throw new Error('Body is null')
+    }
+    const reader = res.body.getReader()
+    const { value } = await reader.read()
+    expect(value).toBeUndefined()
+    expect(onError).toBeCalledTimes(1)
+    expect(onError).toBeCalledWith(new Error('error'), expect.anything()) // 2nd argument is StreamingApi instance
+  })
+})

package/plugins/acryl-router/src/core/helper/streaming/stream.ts

@@ -0,0 +1,45 @@
+import type { Context } from '../../context.ts'
+import { StreamingApi } from '../../utils/stream.ts'
+import { isOldBunVersion } from './utils.ts'
+
+const contextStash: WeakMap<ReadableStream, Context> = new WeakMap<ReadableStream, Context>()
+
+export const stream = (
+  c: Context,
+  cb: (stream: StreamingApi) => Promise<void>,
+  onError?: (e: Error, stream: StreamingApi) => Promise<void>
+): Response => {
+  const { readable, writable } = new TransformStream()
+  const stream = new StreamingApi(writable, readable)
+
+  // Until Bun v1.1.27, Bun didn't call cancel() on the ReadableStream for Response objects from Bun.serve()
+  if (isOldBunVersion()) {
+    c.req.raw.signal.addEventListener('abort', () => {
+      if (!stream.closed) {
+        stream.abort()
+      }
+    })
+  }
+
+  // in bun, `c` is destroyed when the request is returned, so hold it until the end of streaming
+  contextStash.set(stream.responseReadable, c)
+  ;(async () => {
+    try {
+      await cb(stream)
+    } catch (e) {
+      if (e === undefined) {
+        // If reading is canceled without a reason value (e.g. by StreamingApi)
+        // then the .pipeTo() promise will reject with undefined.
+        // In this case, do nothing because the stream is already closed.
+      } else if (e instanceof Error && onError) {
+        await onError(e, stream)
+      } else {
+        console.error(e)
+      }
+    } finally {
+      stream.close()
+    }
+  })()
+
+  return c.newResponse(stream.responseReadable)
+}