acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-router/src/core/middleware/trailing-slash/index.test.ts

@@ -0,0 +1,381 @@
+import { appendTrailingSlash, trimTrailingSlash } from './index.ts'
+import { App } from '../../app.ts'
+
+describe('Resolve trailing slash', () => {
+  describe('trimTrailingSlash middleware', () => {
+    const app = new App({ strict: true })
+    app.use('*', trimTrailingSlash())
+
+    app.get('/', async (c) => {
+      return c.text('ok')
+    })
+    app.get('/the/example/endpoint/without/trailing/slash', async (c) => {
+      return c.text('ok')
+    })
+
+    it('should handle GET request for root path correctly', async () => {
+      const resp = await app.request('/')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle GET request for path without trailing slash correctly', async () => {
+      const resp = await app.request('/the/example/endpoint/without/trailing/slash')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle GET request for path with trailing slash correctly', async () => {
+      const resp = await app.request('/the/example/endpoint/without/trailing/slash/')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/the/example/endpoint/without/trailing/slash')
+    })
+
+    it('should preserve query parameters when redirecting', async () => {
+      const resp = await app.request('/the/example/endpoint/without/trailing/slash/?exampleParam=1')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/the/example/endpoint/without/trailing/slash')
+      expect(loc.searchParams.get('exampleParam')).toBe('1')
+    })
+
+    it('should handle HEAD request for root path correctly', async () => {
+      const resp = await app.request('/', { method: 'HEAD' })
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle HEAD request for path without trailing slash correctly', async () => {
+      const resp = await app.request('/the/example/endpoint/without/trailing/slash', {
+        method: 'HEAD',
+      })
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle HEAD request for path with trailing slash correctly', async () => {
+      const resp = await app.request('/the/example/endpoint/without/trailing/slash/', {
+        method: 'HEAD',
+      })
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/the/example/endpoint/without/trailing/slash')
+    })
+
+    it('should preserve query parameters when redirecting HEAD requests', async () => {
+      const resp = await app.request(
+        '/the/example/endpoint/without/trailing/slash/?exampleParam=1',
+        { method: 'HEAD' }
+      )
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/the/example/endpoint/without/trailing/slash')
+      expect(loc.searchParams.get('exampleParam')).toBe('1')
+    })
+  })
+
+  describe('trimTrailingSlash middleware with alwaysRedirect option', () => {
+    const app = new App()
+    app.use('*', trimTrailingSlash({ alwaysRedirect: true }))
+
+    app.get('/', async (c) => {
+      return c.text('ok')
+    })
+    app.get('/my-path/*', async (c) => {
+      return c.text('wildcard')
+    })
+    app.get('/exact-path', async (c) => {
+      return c.text('exact')
+    })
+
+    it('should handle GET request for root path correctly', async () => {
+      const resp = await app.request('/')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should redirect wildcard route with trailing slash', async () => {
+      const resp = await app.request('/my-path/something/else/')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/my-path/something/else')
+    })
+
+    it('should not redirect wildcard route without trailing slash', async () => {
+      const resp = await app.request('/my-path/something/else')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+      expect(await resp.text()).toBe('wildcard')
+    })
+
+    it('should redirect exact route with trailing slash', async () => {
+      const resp = await app.request('/exact-path/')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/exact-path')
+    })
+
+    it('should preserve query parameters when redirecting', async () => {
+      const resp = await app.request('/my-path/something/?param=1')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/my-path/something')
+      expect(loc.searchParams.get('param')).toBe('1')
+    })
+
+    it('should handle HEAD request for wildcard route with trailing slash', async () => {
+      const resp = await app.request('/my-path/something/', { method: 'HEAD' })
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/my-path/something')
+    })
+  })
+
+  describe('appendTrailingSlash middleware', () => {
+    const app = new App({ strict: true })
+    app.use('*', appendTrailingSlash())
+
+    app.get('/', async (c) => {
+      return c.text('ok')
+    })
+    app.get('/the/example/endpoint/with/trailing/slash/', async (c) => {
+      return c.text('ok')
+    })
+    app.get('/the/example/simulate/a.file', async (c) => {
+      return c.text('ok')
+    })
+
+    it('should handle GET request for root path correctly', async () => {
+      const resp = await app.request('/')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle GET request for file-like paths correctly', async () => {
+      const resp = await app.request('/the/example/simulate/a.file')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle GET request for path with trailing slash correctly', async () => {
+      const resp = await app.request('/the/example/endpoint/with/trailing/slash/')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should redirect path without trailing slash to one with it', async () => {
+      const resp = await app.request('/the/example/endpoint/with/trailing/slash')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/the/example/endpoint/with/trailing/slash/')
+    })
+
+    it('should preserve query parameters when redirecting', async () => {
+      const resp = await app.request('/the/example/endpoint/with/trailing/slash?exampleParam=1')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/the/example/endpoint/with/trailing/slash/')
+      expect(loc.searchParams.get('exampleParam')).toBe('1')
+    })
+
+    it('should handle HEAD request for root path correctly', async () => {
+      const resp = await app.request('/', { method: 'HEAD' })
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle HEAD request for file-like paths correctly', async () => {
+      const resp = await app.request('/the/example/simulate/a.file', { method: 'HEAD' })
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle HEAD request for path with trailing slash correctly', async () => {
+      const resp = await app.request('/the/example/endpoint/with/trailing/slash/', {
+        method: 'HEAD',
+      })
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should redirect HEAD request for path without trailing slash to one with it', async () => {
+      const resp = await app.request('/the/example/endpoint/with/trailing/slash', {
+        method: 'HEAD',
+      })
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/the/example/endpoint/with/trailing/slash/')
+    })
+
+    it('should preserve query parameters when redirecting HEAD requests', async () => {
+      const resp = await app.request('/the/example/endpoint/with/trailing/slash?exampleParam=1', {
+        method: 'HEAD',
+      })
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/the/example/endpoint/with/trailing/slash/')
+      expect(loc.searchParams.get('exampleParam')).toBe('1')
+    })
+  })
+
+  describe('appendTrailingSlash middleware with skip option', () => {
+    const hasExtension = (path: string): boolean => /\.\w+$/.test(path.split('/').at(-1) ?? '')
+    const app = new App({ strict: true })
+    app.use('*', appendTrailingSlash({ skip: hasExtension }))
+
+    app.get('/page/', (c) => c.text('ok'))
+
+    it('should not redirect paths with file extensions', async () => {
+      const resp = await app.request('/foo.html')
+
+      expect(resp.status).toBe(404)
+    })
+
+    it('should redirect paths without file extensions', async () => {
+      const resp = await app.request('/page')
+
+      expect(resp.status).toBe(301)
+      const loc = new URL(resp.headers.get('location')!)
+      expect(loc.pathname).toBe('/page/')
+    })
+  })
+
+  describe('appendTrailingSlash middleware with alwaysRedirect and skip options', () => {
+    const hasExtension = (path: string): boolean => /\.\w+$/.test(path.split('/').at(-1) ?? '')
+    const app = new App()
+    app.use('*', appendTrailingSlash({ alwaysRedirect: true, skip: hasExtension }))
+
+    app.get('/', (c) => c.text('ok'))
+    app.get('/my-path/*', (c) => c.text('wildcard'))
+
+    it('should redirect paths without extensions', async () => {
+      const resp = await app.request('/my-path/something')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/my-path/something/')
+    })
+
+    it('should not redirect paths with file extensions', async () => {
+      const resp = await app.request('/my-path/style.css')
+
+      expect(resp.status).toBe(200)
+    })
+
+    it('should not redirect paths with extensions like .html', async () => {
+      const resp = await app.request('/my-path/page.html')
+
+      expect(resp.status).toBe(200)
+    })
+
+    it('should handle HEAD request for paths with extensions', async () => {
+      const resp = await app.request('/my-path/script.js', { method: 'HEAD' })
+
+      expect(resp.status).toBe(200)
+    })
+  })
+
+  describe('appendTrailingSlash middleware with alwaysRedirect option', () => {
+    const app = new App()
+    app.use('*', appendTrailingSlash({ alwaysRedirect: true }))
+
+    app.get('/', async (c) => {
+      return c.text('ok')
+    })
+    app.get('/my-path/*', async (c) => {
+      return c.text('wildcard')
+    })
+    app.get('/exact-path/', async (c) => {
+      return c.text('exact')
+    })
+
+    it('should handle GET request for root path correctly', async () => {
+      const resp = await app.request('/')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+    })
+
+    it('should redirect wildcard route without trailing slash', async () => {
+      const resp = await app.request('/my-path/something/else')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/my-path/something/else/')
+    })
+
+    it('should not redirect wildcard route with trailing slash', async () => {
+      const resp = await app.request('/my-path/something/else/')
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(200)
+      expect(await resp.text()).toBe('wildcard')
+    })
+
+    it('should redirect exact route without trailing slash', async () => {
+      const resp = await app.request('/exact-path')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/exact-path/')
+    })
+
+    it('should preserve query parameters when redirecting', async () => {
+      const resp = await app.request('/my-path/something?param=1')
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/my-path/something/')
+      expect(loc.searchParams.get('param')).toBe('1')
+    })
+
+    it('should handle HEAD request for wildcard route without trailing slash', async () => {
+      const resp = await app.request('/my-path/something', { method: 'HEAD' })
+      const loc = new URL(resp.headers.get('location')!)
+
+      expect(resp).not.toBeNull()
+      expect(resp.status).toBe(301)
+      expect(loc.pathname).toBe('/my-path/something/')
+    })
+  })
+})

package/plugins/acryl-router/src/core/middleware/trailing-slash/index.ts

@@ -0,0 +1,156 @@
+/**
+ * @module
+ * Trailing Slash Middleware for App.
+ */
+
+import type { MiddlewareHandler } from '../../types.ts'
+
+type TrimTrailingSlashOptions = {
+  /**
+   * If `true`, the middleware will always redirect requests with a trailing slash
+   * before executing handlers.
+   * This is useful for routes with wildcards (`*`).
+   * If `false` (default), it will only redirect when the route is not found (404).
+   * @default false
+   */
+  alwaysRedirect?: boolean
+}
+
+/**
+ * Trailing Slash Middleware for App.
+ *
+ *
+ * @param {TrimTrailingSlashOptions} options - The options for the middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new App()
+ *
+ * app.use(trimTrailingSlash())
+ * app.get('/about/me/', (c) => c.text('With Trailing Slash'))
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With alwaysRedirect option for wildcard routes
+ * const app = new App()
+ *
+ * app.use(trimTrailingSlash({ alwaysRedirect: true }))
+ * app.get('/my-path/*', (c) => c.text('Wildcard route'))
+ * ```
+ */
+export const trimTrailingSlash = (options?: TrimTrailingSlashOptions): MiddlewareHandler => {
+  return async function trimTrailingSlash(c, next) {
+    if (options?.alwaysRedirect) {
+      if (
+        (c.req.method === 'GET' || c.req.method === 'HEAD') &&
+        c.req.path !== '/' &&
+        c.req.path.at(-1) === '/'
+      ) {
+        const url = new URL(c.req.url)
+        url.pathname = url.pathname.substring(0, url.pathname.length - 1)
+
+        return c.redirect(url.toString(), 301)
+      }
+    }
+
+    await next()
+
+    if (
+      !options?.alwaysRedirect &&
+      c.res.status === 404 &&
+      (c.req.method === 'GET' || c.req.method === 'HEAD') &&
+      c.req.path !== '/' &&
+      c.req.path.at(-1) === '/'
+    ) {
+      const url = new URL(c.req.url)
+      url.pathname = url.pathname.substring(0, url.pathname.length - 1)
+
+      c.res = c.redirect(url.toString(), 301)
+    }
+  }
+}
+
+type AppendTrailingSlashOptions = {
+  /**
+   * If `true`, the middleware will always redirect requests without a trailing slash
+   * before executing handlers.
+   * This is useful for routes with wildcards (`*`).
+   * If `false` (default), it will only redirect when the route is not found (404).
+   * @default false
+   */
+  alwaysRedirect?: boolean
+  /**
+   * A function that determines whether to skip the redirect for a given path.
+   * If the function returns `true`, the redirect will be skipped.
+   * @param path - The request path
+   * @returns `true` to skip the redirect
+   *
+   * @example
+   * ```ts
+   * // Skip redirect for paths with file extensions
+   * app.use(appendTrailingSlash({
+   *   alwaysRedirect: true,
+   *   skip: (path) => /\.\w+$/.test(path),
+   * }))
+   * ```
+   */
+  skip?: (path: string) => boolean
+}
+
+/**
+ * Append trailing slash middleware for App.
+ * Append a trailing slash to the URL if it doesn't have one. For example, `/path/to/page` will be redirected to `/path/to/page/`.
+ *
+ *
+ * @param {AppendTrailingSlashOptions} options - The options for the middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new App()
+ *
+ * app.use(appendTrailingSlash())
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With alwaysRedirect option for wildcard routes
+ * const app = new App()
+ *
+ * app.use(appendTrailingSlash({ alwaysRedirect: true }))
+ * app.get('/my-path/*', (c) => c.text('Wildcard route'))
+ * ```
+ */
+export const appendTrailingSlash = (options?: AppendTrailingSlashOptions): MiddlewareHandler => {
+  return async function appendTrailingSlash(c, next) {
+    if (options?.alwaysRedirect) {
+      if (
+        (c.req.method === 'GET' || c.req.method === 'HEAD') &&
+        c.req.path.at(-1) !== '/' &&
+        !options.skip?.(c.req.path)
+      ) {
+        const url = new URL(c.req.url)
+        url.pathname += '/'
+
+        return c.redirect(url.toString(), 301)
+      }
+    }
+
+    await next()
+
+    if (
+      !options?.alwaysRedirect &&
+      c.res.status === 404 &&
+      (c.req.method === 'GET' || c.req.method === 'HEAD') &&
+      c.req.path.at(-1) !== '/' &&
+      !options?.skip?.(c.req.path)
+    ) {
+      const url = new URL(c.req.url)
+      url.pathname += '/'
+
+      c.res = c.redirect(url.toString(), 301)
+    }
+  }
+}

package/plugins/acryl-router/src/core/request/constants.ts

@@ -0,0 +1 @@
+export const GET_MATCH_RESULT: unique symbol = Symbol()