acrylblends 0.6.2 → 0.6.4

package/plugins/acryl-router/tests/docs-examples.spec.ts

@@ -1,152 +0,0 @@
-/**
- * The examples `docs/framework/` relies on, run as written: if one of these fails, the page that shows it is wrong.
- */
-
-import { Context } from '@deepseek-ai/cordis'
-import z from '@deepseek-ai/schemastery'
-import { afterEach, describe, expect, it } from 'vitest'
-import { createMiddleware, schemaValidator, testClient } from '../src/helpers/index.ts'
-import { Acryl, HTTPException, apply, name } from '../src/index.ts'
-import { methodNotAllowed } from '../src/middleware/index.ts'
-
-const contexts: Context[] = []
-const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0))
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-async function withPlugin(plugin: { name: string, inject: string[], apply(ctx: Context): void }): Promise<Context> {
-  const ctx = new Context()
-  contexts.push(ctx)
-  ctx.plugin({ name, apply })
-  ctx.plugin(plugin)
-  await settle()
-  return ctx
-}
-
-describe('getting-started.md', () => {
-  it('serves the minimal plugin as the route table says', async () => {
-    const ctx = await withPlugin({
-      name: 'todo',
-      inject: ['router'],
-      apply(inner) {
-        const app = new Acryl()
-          .get('/', c => c.json({ ok: true }))
-          .get('/todos/:id', c => c.json({ id: c.req.param('id') }))
-        inner.router.route('/todo', app)
-        inner.inject(['routerHttp'], deeper => { deeper.routerHttp.mount('/todo') })
-      },
-    })
-    expect(await (await ctx.router.request('/todo')).json()).toEqual({ ok: true })
-    expect(await (await ctx.router.request('/todo/todos/42')).json()).toEqual({ id: '42' })
-    expect((await ctx.router.request('/todo/')).status).toBe(404)
-  })
-})
-
-describe('routing.md', () => {
-  it('serves the routes an app had at the mount, not ones added later', async () => {
-    const app = new Acryl().get('/a', c => c.text('a'))
-    const ctx = await withPlugin({ name: 'late', inject: ['router'], apply(inner) { inner.router.route('/x', app) } })
-    app.get('/b', c => c.text('b'))
-    expect((await ctx.router.request('/x/a')).status).toBe(200)
-    expect((await ctx.router.request('/x/b')).status).toBe(404)
-  })
-
-  it('answers a wrong method with 404, or 405 and Allow with methodNotAllowed', async () => {
-    const plain = new Acryl().get('/item', c => c.text('item'))
-    expect((await plain.request('/item', { method: 'POST' })).status).toBe(404)
-    const strict = new Acryl()
-    strict.use(methodNotAllowed({ app: strict })).get('/item', c => c.text('item'))
-    const response = await strict.request('/item', { method: 'POST' })
-    expect(response.status).toBe(405)
-    expect(response.headers.get('allow')).toContain('GET')
-
-    const ctx = await withPlugin({ name: 'items', inject: ['router'], apply(inner) { inner.router.route('/shop', strict) } })
-    const mounted = await ctx.router.request('/shop/item', { method: 'POST' })
-    expect(mounted.status).toBe(405)
-    expect(mounted.headers.get('allow')).toContain('GET')
-    expect((await ctx.router.request('/shop/item')).status).toBe(200)
-  })
-
-  it('uses a mounted app\'s onError for its routes', async () => {
-    const app = new Acryl().get('/boom', () => { throw new Error('boom') })
-    app.onError((_error, c) => c.json({ error: 'internal_error' }, 500))
-    const ctx = await withPlugin({ name: 'errors', inject: ['router'], apply(inner) { inner.router.route('/', app) } })
-    expect(await (await ctx.router.request('/boom')).json()).toEqual({ error: 'internal_error' })
-  })
-})
-
-describe('context.md and middleware.md', () => {
-  it('passes typed variables from middleware to the handler', async () => {
-    const withUser = createMiddleware<{ Variables: { user: { name: string } } }>(async (c, next) => {
-      c.set('user', { name: 'ada' })
-      await next()
-    })
-    const app = new Acryl().use(withUser).get('/me', c => c.json(c.var.user))
-    expect(await (await app.request('/me')).json()).toEqual({ name: 'ada' })
-  })
-
-  it('never throws from next(): the error is already a response and is left in c.error', async () => {
-    let caught = false
-    let seen: unknown
-    const app = new Acryl()
-      .use(async (c, next) => {
-        try {
-          await next()
-        } catch {
-          caught = true
-        }
-        seen = c.error
-      })
-      .get('/', () => { throw new Error('boom') })
-    expect((await app.request('/')).status).toBe(500)
-    expect(caught).toBe(false)
-    expect(seen).toBeInstanceOf(Error)
-  })
-
-  it('turns an HTTPException into its own response', async () => {
-    const app = new Acryl().get('/', () => { throw new HTTPException(403, { message: 'not yours' }) })
-    const response = await app.request('/')
-    expect(response.status).toBe(403)
-    expect(await response.text()).toBe('not yours')
-  })
-})
-
-describe('validation.md', () => {
-  const NewTodo = z.object({
-    title: z.string().required(),
-    done: z.boolean().default(false),
-  })
-  const app = new Acryl().post('/todos', schemaValidator('json', NewTodo), c => c.json({ todo: c.req.valid('json') }, 201))
-  const post = (body: string, type?: string): Promise<Response> =>
-    Promise.resolve(app.request('/todos', { method: 'POST', body, headers: type === undefined ? {} : { 'content-type': type } }))
-
-  it('hands the handler the schema output', async () => {
-    const response = await post('{"title":"hello"}', 'application/json')
-    expect(response.status).toBe(201)
-    expect(await response.json()).toEqual({ todo: { title: 'hello', done: false } })
-  })
-
-  it('answers 400 with the issues the page shows', async () => {
-    const response = await post('{"title":1}', 'application/json')
-    expect(response.status).toBe(400)
-    expect(await response.json()).toEqual({ error: 'invalid json', issues: [{ message: '$.title expected string but got 1', path: 'title' }] })
-  })
-
-  it('validates {} when the request is not JSON, so a required field fails', async () => {
-    expect((await post('{"title":"hello"}')).status).toBe(400)
-  })
-
-  it('answers 400 for a body that is not JSON', async () => {
-    expect((await post('{', 'application/json')).status).toBe(400)
-  })
-})
-
-describe('helpers.md', () => {
-  it('calls a chained app through the typed test client', async () => {
-    const app = new Acryl().get('/search', c => c.json({ query: c.req.query('q') }))
-    const client = testClient(app)
-    const response = await client.search.$get({ query: { q: 'cordis' } })
-    expect(await response.json()).toEqual({ query: 'cordis' })
-  })
-})

package/plugins/acryl-router/tests/live-install.spec.ts

@@ -1,64 +0,0 @@
-/**
- * Mounting a plugin after startup from inside a Service method (what an Extensions service does). Inside a service method `this.ctx` is Cordis's
- * "shadow" context, which resolves services as the SERVICE'S OWN fiber; a child plugin mounted with it inherits that shadow, so its `ctx.router`
- * is looked up in the installer's fiber (which never injected it) and throws "cannot get property router without inject", even though the child's
- * own `fiber.inject` and `ctx.get('router')` are fine. The context captured in the constructor is not shadowed and mounts a plugin that behaves
- * exactly like one mounted at startup.
- */
-import { Context, Service } from '@deepseek-ai/cordis'
-import { afterEach, describe, expect, it } from 'vitest'
-import { Acryl, apply, name } from '../src/index.ts'
-
-const contexts: Context[] = []
-const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0))
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-class Installer extends Service {
-  private readonly owner: Context
-  constructor(ctx: Context) {
-    super(ctx, 'installer')
-    this.owner = ctx
-  }
-
-  /** Right: mount from the context captured in the constructor. */
-  async install(module: object): Promise<void> {
-    await this.owner.plugin(module as { apply(ctx: Context): void })
-  }
-
-  /** Wrong: `this.ctx` inside a method is the shadow context. */
-  async installFromShadow(module: object): Promise<void> {
-    await this.ctx.plugin(module as { apply(ctx: Context): void })
-  }
-}
-
-async function system(): Promise<Context & { installer: Installer }> {
-  const root = new Context()
-  contexts.push(root)
-  root.plugin({ name, apply })
-  root.plugin({ name: 'installer', apply: (ctx: Context) => { new Installer(ctx) } })
-  await settle()
-  return root as Context & { installer: Installer }
-}
-
-const extension = (): object => ({
-  name: 'live-ext',
-  inject: ['router'],
-  apply(ctx: Context): void {
-    ctx.router.route('/', new Acryl().get('/live', c => c.json({ ok: true })))
-  },
-})
-
-describe('live install from a service method', () => {
-  it('works from the constructor context: the plugin reads ctx.router like one mounted at startup', async () => {
-    const root = await system()
-    await root.installer.install(extension())
-    expect(await (await root.router.request('/live')).json()).toEqual({ ok: true })
-  })
-
-  it('fails from this.ctx, which is Cordis behavior the framework docs warn about', async () => {
-    const root = await system()
-    await expect(root.installer.installFromShadow(extension())).rejects.toThrow(/cannot get property "router" without inject/u)
-  })
-})

package/plugins/acryl-router/tests/loader.spec.ts

@@ -1,72 +0,0 @@
-/**
- * The router mounted the way production mounts every plugin: a real `@deepseek-ai/cordis-plugin-loader` Loader row
- * pointing at the built `lib/index.js`. Covers what a hand-built `ctx.plugin` cannot: the row id equals the package
- * name, the `cordis.patch.yml` insert is loadable, and disabling and enabling the row ten times leaves nothing behind.
- * @throws if the package has not been built: run `pnpm run build` first.
- */
-
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { Context, type FiberState } from '@deepseek-ai/cordis'
-import { Loader } from '@deepseek-ai/cordis-plugin-loader'
-import { afterEach, describe, expect, it } from 'vitest'
-import { Acryl } from '../src/index.ts'
-
-const ACTIVE = 2 as FiberState.ACTIVE
-const DISPOSED = 4 as FiberState.DISPOSED
-const BUILT_ENTRY = new URL('../lib/index.js', import.meta.url).href
-
-const roots: string[] = []
-const contexts: Context[] = []
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
-})
-
-async function mount(): Promise<{ ctx: Context, entryId: string }> {
-  const root = mkdtempSync(join(tmpdir(), 'acryl-router-loader-'))
-  roots.push(root)
-  writeFileSync(join(root, 'row.mjs'), `export * from ${JSON.stringify(BUILT_ENTRY)}\n`)
-  const ctx = new Context()
-  contexts.push(ctx)
-  await ctx.plugin(Loader, { baseUrl: `file://${root}/` })
-  const entryId = await ctx.loader.create({ name: './row.mjs' })
-  await ctx.loader.await()
-  return { ctx, entryId }
-}
-
-function entryOf(ctx: Context, entryId: string) {
-  const found = [...ctx.loader.entries()].find(candidate => candidate.id === entryId)
-  if (found === undefined) throw new Error('entry not found')
-  return found
-}
-
-describe('acryl-router through a real Loader', () => {
-  it('activates from the built entry and serves a request in process', async () => {
-    const { ctx, entryId } = await mount()
-    expect(entryOf(ctx, entryId).fiber?.state).toBe(ACTIVE)
-    ctx.router.route('/', new Acryl().get('/ping', c => c.json({ ok: true })))
-    const response = await ctx.router.fetch(new Request('http://acryl.test/ping'))
-    expect(await response.json()).toEqual({ ok: true })
-  })
-
-  it('answers 503 and drops its routes when the row is disabled, and serves again when re-enabled, ten times', async () => {
-    const { ctx, entryId } = await mount()
-    const first = ctx.router
-    for (let i = 0; i < 10; i += 1) {
-      await entryOf(ctx, entryId).update({ disabled: true })
-      await ctx.loader.await()
-      const fiber = entryOf(ctx, entryId).fiber
-      expect(fiber === undefined || fiber.state === DISPOSED).toBe(true)
-      await entryOf(ctx, entryId).update({ disabled: false })
-      await ctx.loader.await()
-      expect(entryOf(ctx, entryId).fiber?.state).toBe(ACTIVE)
-    }
-    expect(ctx.router).not.toBe(first)
-    expect(ctx.router.size).toBe(0)
-    expect((await first.fetch(new Request('http://acryl.test/x'))).status).toBe(503)
-    ctx.router.route('/', new Acryl().get('/again', c => c.text('ok')))
-    expect(await (await ctx.router.fetch(new Request('http://acryl.test/again'))).text()).toBe('ok')
-  })
-})

package/plugins/acryl-router/tests/loopback-only.spec.ts

@@ -1,80 +0,0 @@
-/**
- * `loopbackOnly`, the guard of a local app's own routes: the peer and port come from the transport, the `Host` names this app, and the
- * `callers` rule decides whether any local program or only the app's own page may call.
- */
-
-import { describe, expect, it } from 'vitest'
-import { Acryl, type ConnectionInfo } from '../src/index.ts'
-import { loopbackOnly, type LoopbackOptions } from '../src/middleware/index.ts'
-
-const PORT = 43_120
-const SELF = `http://127.0.0.1:${String(PORT)}`
-const LOCAL: ConnectionInfo = { remoteAddress: '127.0.0.1', localPort: PORT }
-
-function guarded(options: LoopbackOptions = {}): Acryl {
-  return new Acryl().use(loopbackOnly(options)).get('/x', c => c.text('read')).post('/x', c => c.text('changed'))
-}
-
-async function status(
-  app: Acryl,
-  method: string,
-  headers: Record<string, string>,
-  connection: ConnectionInfo = LOCAL,
-): Promise<number> {
-  const response = await app.fetch(new Request(`${SELF}/x`, { method, headers: { host: `127.0.0.1:${String(PORT)}`, ...headers } }), { connection })
-  return response.status
-}
-
-describe('loopbackOnly, callers: local (the default)', () => {
-  const app = guarded()
-
-  it('lets a local program read and change, and a page of this app change', async () => {
-    expect(await status(app, 'GET', {})).toBe(200)
-    expect(await status(app, 'POST', {})).toBe(200)
-    expect(await status(app, 'POST', { origin: SELF })).toBe(200)
-  })
-
-  it('refuses another origin\'s change, a foreign peer, a wrong port, a foreign Host and an in-process call', async () => {
-    expect(await status(app, 'POST', { origin: 'http://evil.test' })).toBe(403)
-    expect(await status(app, 'GET', {}, { remoteAddress: '192.168.1.5', localPort: PORT })).toBe(403)
-    expect(await status(app, 'GET', {}, { remoteAddress: '127.0.0.1', localPort: PORT + 1 })).toBe(403)
-    expect(await status(app, 'GET', { host: 'evil.test' })).toBe(403)
-    expect(await status(app, 'GET', {}, {})).toBe(403)
-  })
-
-  it('lets an in-process call through only when the host says so', async () => {
-    expect(await status(guarded({ inProcess: 'allow' }), 'GET', {}, {})).toBe(200)
-  })
-})
-
-describe('loopbackOnly, callers: own-page', () => {
-  const app = guarded({ callers: 'own-page', hostnames: ['127.0.0.1'] })
-
-  it('lets this app\'s page read and change with its exact Origin', async () => {
-    expect(await status(app, 'GET', { origin: SELF, 'sec-fetch-site': 'same-origin' })).toBe(200)
-    expect(await status(app, 'POST', { origin: SELF, 'sec-fetch-site': 'same-origin' })).toBe(200)
-    expect(await status(app, 'POST', { origin: SELF })).toBe(200)
-  })
-
-  it('lets a same-origin read without Origin through by its Referer, as browsers send it', async () => {
-    expect(await status(app, 'GET', { 'sec-fetch-site': 'same-origin', referer: `${SELF}/page?tab=1` })).toBe(200)
-  })
-
-  it('refuses a local program (no Origin), even for a read', async () => {
-    expect(await status(app, 'GET', {})).toBe(403)
-    expect(await status(app, 'POST', {})).toBe(403)
-  })
-
-  it('refuses a change that only has the read evidence, and Origin forms that are not exact', async () => {
-    expect(await status(app, 'POST', { 'sec-fetch-site': 'same-origin', referer: `${SELF}/` })).toBe(403)
-    expect(await status(app, 'POST', { origin: `${SELF}/` })).toBe(403)
-    expect(await status(app, 'POST', { origin: 'null' })).toBe(403)
-    expect(await status(app, 'POST', { origin: SELF, 'sec-fetch-site': 'same-site' })).toBe(403)
-  })
-
-  it('refuses another page, a Referer from elsewhere and a Host this app does not answer to', async () => {
-    expect(await status(app, 'GET', { origin: 'http://evil.test', 'sec-fetch-site': 'cross-site' })).toBe(403)
-    expect(await status(app, 'GET', { 'sec-fetch-site': 'same-origin', referer: 'http://evil.test/' })).toBe(403)
-    expect(await status(app, 'GET', { host: `localhost:${String(PORT)}`, origin: `http://localhost:${String(PORT)}` })).toBe(403)
-  })
-})

package/plugins/acryl-router/tests/no-dom/consumer.ts

@@ -1,11 +0,0 @@
-/**
- * A Host-only consumer: Node types and no DOM library. Typechecking this against the built `lib/types` proves every public entry point's
- * declarations stand without the DOM library, which a server plugin should not need to load.
- */
-
-import type * as Router from '../../src/index.ts'
-import type * as Client from '../../src/client.ts'
-import type * as Helpers from '../../src/helpers/index.ts'
-import type * as Middleware from '../../src/middleware/index.ts'
-
-export type Entries = [typeof Router, typeof Client, typeof Helpers, typeof Middleware]

package/plugins/acryl-router/tests/no-dom/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2024",
-    "lib": ["ES2024"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "strict": true,
-    "exactOptionalPropertyTypes": true,
-    "noEmit": true,
-    "types": ["node"]
-  },
-  "files": ["consumer.ts"]
-}