acrylblends 0.6.2 → 0.6.4

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

@@ -1,434 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { expectTypeOf } from 'vitest'
-import { hc } from '../../client/index.ts'
-import type { ClientRequest } from '../../client/types.ts'
-import { Acryl } from '../../index.ts'
-import type { Env, ExtractSchema, H, MiddlewareHandler, ToSchema, TypedResponse } from '../../types.ts'
-import type { ContentfulStatusCode } from '../../utils/http-status.ts'
-import type { Equal, Expect } from '../../utils/types.ts'
-import { validator } from '../../validator/index.ts'
-import { createFactory, createMiddleware } from './index.ts'
-
-describe('createMiddleware', () => {
-  type Env = { Variables: { foo: string } }
-  const app = new Acryl()
-
-  const mw = (message: string) =>
-    createMiddleware<Env>(async (c, next) => {
-      expectTypeOf(c.var.foo).toEqualTypeOf<string>()
-      c.set('foo', 'bar')
-      await next()
-      c.header('X-Message', message)
-    })
-
-  const route = app.get('/message', mw('Hello Middleware'), (c) => {
-    return c.text(`Hey, ${c.var.foo}`)
-  })
-
-  it('Should return the correct header and the content', async () => {
-    const res = await app.request('/message')
-    expect(res.status).toBe(200)
-    expect(res.headers.get('x-message')).toBe('Hello Middleware')
-    expect(await res.text()).toBe('Hey, bar')
-  })
-
-  it('Should provide the correct types', async () => {
-    const client = hc<typeof route>('http://localhost')
-    const url = client.message.$url()
-    expect(url.pathname).toBe('/message')
-  })
-
-  it('Should pass generics types to chained handlers', () => {
-    type Bindings = {
-      MY_VAR_IN_BINDINGS: string
-    }
-
-    type Variables = {
-      MY_VAR: string
-    }
-
-    const app = new Acryl<{ Bindings: Bindings }>()
-
-    app.get(
-      '/',
-      createMiddleware<{ Variables: Variables }>(async (c, next) => {
-        await next()
-      }),
-      createMiddleware(async (c, next) => {
-        await next()
-      }),
-      async (c) => {
-        const v = c.get('MY_VAR')
-        expectTypeOf(v).toEqualTypeOf<string>()
-      }
-    )
-  })
-
-  it('Should default to MiddlewareHandler<E, P, I, Response>', async () => {
-    const middleware = createMiddleware(async (c, next) => {
-      await next()
-    })
-    type Expected = MiddlewareHandler<any, string, {}, Response>
-    type _verify = Expect<Equal<Expected, typeof middleware>>
-  })
-})
-
-describe('createHandler', () => {
-  const mw = (message: string) =>
-    createMiddleware(async (c, next) => {
-      await next()
-      c.header('x-message', message)
-    })
-
-  describe('Basic', () => {
-    const factory = createFactory()
-    const app = new Acryl()
-
-    const handlersA = factory.createHandlers((c) => {
-      return c.text('A')
-    })
-    const routesA = app.get('/a', ...handlersA)
-
-    const handlersB = factory.createHandlers(mw('B'), (c) => {
-      return c.text('B')
-    })
-    app.get('/b', ...handlersB)
-
-    it('Should return 200 response - GET /a', async () => {
-      const res = await app.request('/a')
-      expect(res.status).toBe(200)
-      expect(await res.text()).toBe('A')
-    })
-
-    it('Should return 200 response with a custom header - GET /b', async () => {
-      const res = await app.request('/b')
-      expect(res.status).toBe(200)
-      expect(res.headers.get('x-message')).toBe('B')
-      expect(await res.text()).toBe('B')
-    })
-
-    it('Should return correct path types - /a', () => {
-      const client = hc<typeof routesA>('/')
-      expectTypeOf(client).toEqualTypeOf<{
-        a: ClientRequest<
-          string,
-          '/a',
-          {
-            $get: {
-              input: {}
-              output: 'A'
-              outputFormat: 'text'
-              status: ContentfulStatusCode
-            }
-          }
-        >
-      }>()
-    })
-  })
-
-  describe('Types', () => {
-    type Env = { Variables: { foo: string } }
-
-    const factory = createFactory<Env>()
-    const app = new Acryl<Env>()
-
-    const handlers = factory.createHandlers(
-      validator('query', () => {
-        return {
-          page: '1',
-        }
-      }),
-      (c) => {
-        const foo = c.var.foo
-        const { page } = c.req.valid('query')
-        return c.json({ page, foo })
-      }
-    )
-    const routes = app.get('/posts', ...handlers)
-
-    type Expected = Acryl<
-      Env,
-      ToSchema<
-        'get',
-        '/posts',
-        {
-          in: {
-            query: {
-              page: string
-            }
-          }
-        },
-        TypedResponse<{
-          page: string
-          foo: string
-        }>
-      >,
-      '/'
-    >
-
-    it('Should return correct types', () => {
-      expectTypeOf(routes).toEqualTypeOf<Expected>()
-    })
-  })
-
-  // It's difficult to cover all possible patterns,
-  // so these tests will only cover the minimal cases.
-
-  describe('Types - Complex', () => {
-    type Env = { Variables: { foo: string } }
-
-    const factory = createFactory<Env>()
-    const app = new Acryl<Env>()
-
-    const handlers = factory.createHandlers(
-      validator('header', () => {
-        return {
-          auth: 'token',
-        }
-      }),
-      validator('query', () => {
-        return {
-          page: '1',
-        }
-      }),
-      validator('json', () => {
-        return {
-          id: 123,
-        }
-      }),
-      (c) => {
-        const foo = c.var.foo
-        const { auth } = c.req.valid('header')
-        const { page } = c.req.valid('query')
-        const { id } = c.req.valid('json')
-        return c.json({ auth, page, foo, id })
-      }
-    )
-    const routes = app.get('/posts', ...handlers)
-
-    type Expected = Acryl<
-      Env,
-      ToSchema<
-        'get',
-        '/posts',
-        {
-          in: {
-            header: {
-              auth: string
-            }
-          } & {
-            query: {
-              page: string
-            }
-          } & {
-            json: {
-              id: number
-            }
-          }
-        },
-        TypedResponse<{
-          auth: string
-          page: string
-          foo: string
-          id: number
-        }>
-      >,
-      '/'
-    >
-
-    it('Should return correct types', () => {
-      expectTypeOf(routes).toEqualTypeOf<Expected>()
-    })
-  })
-
-  describe('Types - Context Env with Multiple Middlewares', () => {
-    const factory = createFactory()
-
-    const mw1 = createMiddleware<
-      { Variables: { foo1: string } },
-      string,
-      { out: { query: { bar1: number } } }
-    >(async () => {})
-    const mw2 = createMiddleware<
-      { Variables: { foo2: string } },
-      string,
-      { out: { query: { bar2: number } } }
-    >(async () => {})
-    const mw3 = createMiddleware<
-      { Variables: { foo3: string } },
-      string,
-      { out: { query: { bar3: number } } }
-    >(async () => {})
-    const mw4 = createMiddleware<
-      { Variables: { foo4: string } },
-      string,
-      { out: { query: { bar4: number } } }
-    >(async () => {})
-    const mw5 = createMiddleware<
-      { Variables: { foo5: string } },
-      string,
-      { out: { query: { bar5: number } } }
-    >(async () => {})
-    const mw6 = createMiddleware<
-      { Variables: { foo6: string } },
-      string,
-      { out: { query: { bar6: number } } }
-    >(async () => {})
-    const mw7 = createMiddleware<
-      { Variables: { foo7: string } },
-      string,
-      { out: { query: { bar7: number } } }
-    >(async () => {})
-    const mw8 = createMiddleware<
-      { Variables: { foo8: string } },
-      string,
-      { out: { query: { bar8: number } } }
-    >(async () => {})
-    const mw9 = createMiddleware<
-      { Variables: { foo9: string } },
-      string,
-      { out: { query: { bar9: number } } }
-    >(async () => {})
-
-    it('Should not throw type error', () => {
-      factory.createHandlers(
-        mw1,
-        mw2,
-        mw3,
-        mw4,
-        mw5,
-        mw6,
-        mw7,
-        mw8,
-        async (c) => {
-          expectTypeOf(c.var.foo1).toEqualTypeOf<string>()
-          expectTypeOf(c.var.foo2).toEqualTypeOf<string>()
-          expectTypeOf(c.var.foo3).toEqualTypeOf<string>()
-          expectTypeOf(c.var.foo4).toEqualTypeOf<string>()
-          expectTypeOf(c.var.foo5).toEqualTypeOf<string>()
-          expectTypeOf(c.var.foo6).toEqualTypeOf<string>()
-          expectTypeOf(c.var.foo7).toEqualTypeOf<string>()
-          expectTypeOf(c.var.foo8).toEqualTypeOf<string>()
-        },
-        (c) => c.json(0)
-      )
-
-      factory.createHandlers(mw1, mw2, mw3, mw4, mw5, mw6, mw7, mw8, mw9, (c) => {
-        expectTypeOf(c.var.foo1).toEqualTypeOf<string>()
-        expectTypeOf(c.var.foo2).toEqualTypeOf<string>()
-        expectTypeOf(c.var.foo3).toEqualTypeOf<string>()
-        expectTypeOf(c.var.foo4).toEqualTypeOf<string>()
-        expectTypeOf(c.var.foo5).toEqualTypeOf<string>()
-        expectTypeOf(c.var.foo6).toEqualTypeOf<string>()
-        expectTypeOf(c.var.foo7).toEqualTypeOf<string>()
-        expectTypeOf(c.var.foo8).toEqualTypeOf<string>()
-        expectTypeOf(c.var.foo9).toEqualTypeOf<string>()
-
-        return c.json({
-          foo1: c.get('foo1'),
-          foo2: c.get('foo2'),
-          foo3: c.get('foo3'),
-          foo4: c.get('foo4'),
-          foo5: c.get('foo5'),
-          foo6: c.get('foo6'),
-          foo7: c.get('foo7'),
-          foo8: c.get('foo8'),
-          foo9: c.get('foo9'),
-        })
-      })
-    })
-  })
-
-  describe('Types - Multiple Handlers', () => {
-    const factory = createFactory()
-
-    const [handler1, handler2] = factory.createHandlers(
-      (c) => c.json({ first: 1 }),
-      (c) => c.json({ second: 'second' as const })
-    )
-
-    type ExtractOutput<R> = R extends H<any, any, any, TypedResponse<infer Inner>> ? Inner : never
-
-    type Handler1Output = ExtractOutput<typeof handler1>
-    type Handler2Output = ExtractOutput<typeof handler2>
-
-    it('Should allow multiple handlers with independent return types', () => {
-      expectTypeOf<Handler1Output>().toEqualTypeOf<{ first: number }>()
-      expectTypeOf<Handler2Output>().toEqualTypeOf<{ second: 'second' }>()
-    })
-  })
-})
-
-describe('createFactory', () => {
-  describe('createApp', () => {
-    type Env = { Variables: { foo: string } }
-    const factory = createFactory<Env>({
-      initApp: (app) => {
-        app.use((c, next) => {
-          c.set('foo', 'bar')
-          return next()
-        })
-      },
-    })
-    const app = factory.createApp()
-    it('Should set the correct type and initialize the app', async () => {
-      app.get('/', (c) => {
-        expectTypeOf(c.var.foo).toEqualTypeOf<string>()
-        return c.text(c.var.foo)
-      })
-      const res = await app.request('/')
-      expect(res.status).toBe(200)
-      expect(await res.text()).toBe('bar')
-    })
-  })
-
-  describe('createMiddleware', () => {
-    it('Should omit the `*` wildcard from the generated schema', () => {
-      const factory = createFactory()
-
-      const middleware = factory.createMiddleware(async (_, next) => {
-        await next()
-      })
-
-      const routes = new Acryl().use('*', middleware)
-      type Actual = ExtractSchema<typeof routes>
-      type Expected = {}
-      type verify = Expect<Equal<Expected, Actual>>
-    })
-
-    it('Should default to MiddlewareHandler<E, P, I, Response>', async () => {
-      const factory = createFactory()
-
-      const middleware = factory.createMiddleware(async (c, next) => {
-        await next()
-      })
-      type Expected = MiddlewareHandler<Env, string, {}, Response>
-      type _verify = Expect<Equal<Expected, typeof middleware>>
-    })
-  })
-
-  it('Should use the default app options', async () => {
-    const app = createFactory({ defaultAppOptions: { strict: false } }).createApp()
-    app.get('/hello', (c) => c.text('hello'))
-    const res = await app.request('/hello/')
-    expect(res.status).toBe(200)
-    expect(await res.text()).toBe('hello')
-  })
-
-  it('Should override the default app options when creating', async () => {
-    const app = createFactory({ defaultAppOptions: { strict: true } }).createApp({ strict: false })
-    app.get('/hello', (c) => c.text('hello'))
-    const res = await app.request('/hello/')
-    expect(res.status).toBe(200)
-    expect(await res.text()).toBe('hello')
-  })
-})
-
-describe('Lint rules', () => {
-  it('Should not throw a eslint `unbound-method` error if destructed', () => {
-    const { createApp, createHandlers, createMiddleware } = createFactory()
-    expect(createApp).toBeDefined()
-    expect(createHandlers).toBeDefined()
-    expect(createMiddleware).toBeDefined()
-  })
-})

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

@@ -1,78 +0,0 @@
-import { html, raw } from './index.ts'
-import { HtmlEscapedCallbackPhase, resolveCallback } from '../../utils/html.ts'
-
-describe('Tagged Template Literals', () => {
-  it('Should escape special characters', () => {
-    const name = 'John "Johnny" Smith'
-
-    expect(html`<p>I'm ${name}.</p>`.toString()).toBe("<p>I'm John &quot;Johnny&quot; Smith.</p>")
-  })
-
-  describe('Booleans, Null, and Undefined Are Ignored', () => {
-    it.each([true, false, undefined, null])('%s', (item) => {
-      expect(html`${item}`.toString()).toBe('')
-    })
-
-    it('falsy value', () => {
-      expect(html`${0}`.toString()).toBe('0')
-    })
-  })
-
-  it('Should call $array.flat(Infinity)', () => {
-    const values = [
-      'Name:',
-      ['John "Johnny" Smith', undefined, null],
-      ' Contact:',
-      [html`<a href="http://example.com/">My Website</a>`],
-    ]
-    expect(html`<p>${values}</p>`.toString()).toBe(
-      '<p>Name:John &quot;Johnny&quot; Smith Contact:<a href="http://example.com/">My Website</a></p>'
-    )
-  })
-
-  describe('Promise', () => {
-    it('Should return Promise<string> when some variables contains Promise<string> in variables', async () => {
-      const name = Promise.resolve('John "Johnny" Smith')
-      const res = html`<p>I'm ${name}.</p>`
-      expect(res).toBeInstanceOf(Promise)
-
-      expect((await res).toString()).toBe("<p>I'm John &quot;Johnny&quot; Smith.</p>")
-    })
-
-    it('Should return raw value when some variables contains Promise<HtmlEscapedString> in variables', async () => {
-      const name = Promise.resolve(raw('John "Johnny" Smith'))
-      const res = html`<p>I'm ${name}.</p>`
-      expect(res).toBeInstanceOf(Promise)
-      expect((await res).toString()).toBe('<p>I\'m John "Johnny" Smith.</p>')
-    })
-  })
-
-  describe('HtmlEscapedString', () => {
-    it('Should preserve callbacks', async () => {
-      const name = raw('Acryl', [
-        ({ buffer }) => {
-          if (buffer) {
-            buffer[0] = buffer[0].replace('Acryl', 'Acryl!')
-          }
-          return undefined
-        },
-      ])
-      const res = html`<p>I'm ${name}.</p>`
-      expect(res).toBeInstanceOf(Promise)
-
-      expect((await res).toString()).toBe("<p>I'm Acryl.</p>")
-      expect(await resolveCallback(await res, HtmlEscapedCallbackPhase.Stringify, false, {})).toBe(
-        "<p>I'm Acryl!.</p>"
-      )
-    })
-  })
-})
-
-describe('raw', () => {
-  it('Should be marked as escaped.', () => {
-    const name = 'John &quot;Johnny&quot; Smith'
-    expect(html`<p>I'm ${raw(name)}.</p>`.toString()).toBe(
-      "<p>I'm John &quot;Johnny&quot; Smith.</p>"
-    )
-  })
-})