@toa.io/extensions.exposition 1.0.0-alpha.285 → 1.0.0-alpha.286

package/features/steps/components/users/operations/create.js

@@ -1,4 +1,4 @@
-export function transition (input, object) {
+export function transition(input, object) {
   if (input.name === 'return_error') {
     const e = new Error()
 

package/features/steps/components/users.properties/manifest.toa.yaml

@@ -2,13 +2,12 @@ namespace: users
 name: properties
 
 entity:
-  schema:
-    properties:
-      newbie:
-        type: boolean
-        default: false
-    type: object
   associated: true
+  properties:
+    newbie:
+      type: boolean
+  blank:
+    newbie: false
 
 operations:
   transit:

package/features/steps/map.ts

@@ -12,14 +12,14 @@ const COMPONENTS = ['introspection.nodes', 'introspection.edges']
  * The map's own components, as the introspection package ships them. Mounted rather
  * than copied on purpose: a scenario about a manifest must read that manifest.
  */
-export function components (): string[] {
+export function components(): string[] {
   const root = dirname(require.resolve(PACKAGE + '/package.json'))
 
   return COMPONENTS.map((name) => join(root, 'components', name))
 }
 
 /** `norm` declares `component` as a namespace of types; the runtime export is a function. */
-export async function manifests (): Promise<Manifest[]> {
+export async function manifests(): Promise<Manifest[]> {
   const { component } = norm as unknown as Norm
 
   return await Promise.all(components().map(async (path) => await component(path)))

package/features/timestamps.feature

@@ -37,5 +37,5 @@ Feature: Entity timestamp
       """
       200 OK
       last-modified: ${{ created }}
-      content-length: 149
+      content-length: 145
       """

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/extensions.exposition",
-  "version": "1.0.0-alpha.285",
+  "version": "1.0.0-alpha.286",
   "type": "module",
   "description": "Toa Exposition",
   "author": "temich <tema.gurtovoy@gmail.com>",
@@ -18,11 +18,11 @@
     "access": "public"
   },
   "dependencies": {
+    "@node-rs/bcrypt": "1.10.8",
     "@simplewebauthn/server": "14.0.0",
-    "@toa.io/core": "1.0.0-alpha.284",
-    "@toa.io/generic": "1.0.0-alpha.283",
-    "@toa.io/schemas": "1.0.0-alpha.283",
-    "bcryptjs": "3.0.3",
+    "@toa.io/core": "1.0.0-alpha.286",
+    "@toa.io/generic": "1.0.0-alpha.286",
+    "@toa.io/schemas": "1.0.0-alpha.286",
     "content-type": "3.0.0",
     "jose": "6.2.10",
     "js-yaml": "5.4.1",
@@ -31,7 +31,7 @@
     "minimatch": "10.2.6",
     "msgpackr": "2.1.0",
     "negotiator": "1.1.0",
-    "openspan": "1.0.0-alpha.277",
+    "openspan": "1.0.0-alpha.286",
     "paseto": "4.0.0"
   },
   "scripts": {
@@ -58,5 +58,5 @@
     "@types/cors": "2.8.19",
     "@types/negotiator": "0.6.5"
   },
-  "gitHead": "44ed1be7e322a5ea8f1a8ed85ba96b9dfaf28224"
+  "gitHead": "81f3d0688f17668b902be336d1749cc715edcdb6"
 }

package/readme.md

@@ -130,18 +130,18 @@ exposition:
     example: the.example.com
 ```
 
-| Option        | Description                                                                                                       |
-|---------------|-------------------------------------------------------------------------------------------------------------------|
-| `auhorities`  | Mapping of authority identifiers to domain names. See [Authorities](documentation/authorities.md).                |
-| `class`       | Ingress class.                                                                                                    |
-| `annotations` | Ingress annotations.                                                                                              |
-| `debug`       | Output server errors. Default `false`.                                                                            |
-| `ip`          | Header the client address is read from. See [Client address](documentation/ip.md).                              |
+| Option        | Description                                                                                                                   |
+| ------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `auhorities`  | Mapping of authority identifiers to domain names. See [Authorities](documentation/authorities.md).                            |
+| `class`       | Ingress class.                                                                                                                |
+| `annotations` | Ingress annotations.                                                                                                          |
+| `debug`       | Output server errors. Default `false`.                                                                                        |
+| `ip`          | Header the client address is read from. See [Client address](documentation/ip.md).                                            |
 | `bouncer`     | Meter of failed authentications per address. See [Identity authentication](documentation/identity.md#failed-authentications). |
-| `oauth`       | Authorization server exposed to OAuth clients. See [OAuth](documentation/oauth.md).                               |
-| `protocol`    | `h1` or `h2c`. See [Protocol](documentation/protocol.md).                                                         |
-| `rpc`         | JSON-RPC at `/.rpc`; none is served without it. See [JSON-RPC](documentation/rpc.md).                             |
-| `mcp`         | MCP at `/.mcp`; none is served without it. See [MCP](documentation/mcp.md).                                       |
+| `oauth`       | Authorization server exposed to OAuth clients. See [OAuth](documentation/oauth.md).                                           |
+| `protocol`    | `h1` or `h2c`. See [Protocol](documentation/protocol.md).                                                                     |
+| `rpc`         | JSON-RPC at `/.rpc`; none is served without it. See [JSON-RPC](documentation/rpc.md).                                         |
+| `mcp`         | MCP at `/.mcp`; none is served without it. See [MCP](documentation/mcp.md).                                                   |
 
 ### Observability
 

package/schemas/annotation.cos.yaml

@@ -3,7 +3,7 @@ properties:
     type: string
   resources:
     # `null` deploys the service without any, which every deployment has to state one way
-    # or the other — see `migrations/263.md`.
+    # or the other — see `migrations/262.md`.
     type: object
     nullable: true
     properties:
@@ -76,7 +76,6 @@ properties:
       registration:
         type: string
         enum: [open, closed]
-        default: closed
     required:
       - authorize
     additionalProperties: false
@@ -109,7 +108,6 @@ properties:
       anonymous:
         description: Whether the endpoint answers without a credential
         type: boolean
-        default: false
     required:
       - name
     additionalProperties: false

package/schemas/method.cos.yaml

@@ -12,6 +12,8 @@ properties:
         type: string
       query:
         $ref: query
+      paged:
+        type: boolean
     additionalProperties: false
     type: object
   directives:

package/source/Branch.test.ts

@@ -4,7 +4,7 @@ import assert from 'node:assert/strict'
 import { decide } from './Branch.js'
 import type { Branch, Exposed } from './Branch.js'
 
-function branch (version: string, timestamp: number): Branch {
+function branch(version: string, timestamp: number): Branch {
   return {
     namespace: 'default',
     component: 'one',
@@ -15,7 +15,7 @@ function branch (version: string, timestamp: number): Branch {
   }
 }
 
-function exposed (version: string, timestamp: number): Exposed {
+function exposed(version: string, timestamp: number): Exposed {
   return { version, timestamp, nodes: [] }
 }
 

package/source/Branch.ts

@@ -33,12 +33,10 @@ export interface Exposed {
  * - `superseded`: it came from a tenant that started before the one exposed now
  * - `merge`: everything else
  */
-export function decide (exposed: Exposed, branch: Branch): Decision {
-  if (exposed.version === branch.version)
-    return 'refresh'
+export function decide(exposed: Exposed, branch: Branch): Decision {
+  if (exposed.version === branch.version) return 'refresh'
 
-  if (branch.timestamp < exposed.timestamp)
-    return 'superseded'
+  if (branch.timestamp < exposed.timestamp) return 'superseded'
 
   return 'merge'
 }

package/source/Composition.ts

@@ -6,12 +6,12 @@ import { type Host } from './Factory.js'
 export class Composition extends Connector {
   private readonly host: Host
 
-  public constructor (host: Host) {
+  public constructor(host: Host) {
     super()
     this.host = host
   }
 
-  protected override async open (): Promise<void> {
+  protected override async open(): Promise<void> {
     const paths = find()
     const composition = await this.host.composition(paths)
 
@@ -21,17 +21,17 @@ export class Composition extends Connector {
   }
 }
 
-function find (): string[] {
+function find(): string[] {
   return entries().map((entry) => resolve(ROOT, entry.name))
 }
 
-function entries (): Dirent[] {
+function entries(): Dirent[] {
   const entries = readdirSync(ROOT, { withFileTypes: true })
 
   return entries.filter((entry) => entry.isDirectory())
 }
 
-export function components (): Components {
+export function components(): Components {
   const labels: string[] = []
   const paths: string[] = []
 

package/source/Directive.test.ts

@@ -16,7 +16,10 @@ const families: Array<DirectiveFamily> = [
     mandatory: true,
     create: mock.fn((_0: any, _1: any, _2: any) => generate() as any),
     arrange: mock.fn(),
-    precall: mock.fn(() => { sequence.push('foo'); return null }),
+    precall: mock.fn(() => {
+      sequence.push('foo')
+      return null
+    }),
     settle: mock.fn(),
     dispose: mock.fn()
   },
@@ -25,7 +28,10 @@ const families: Array<DirectiveFamily> = [
     mandatory: true,
     create: mock.fn((_0: any, _1: any, _2: any) => generate() as any),
     arrange: mock.fn(),
-    precall: mock.fn(() => { sequence.push('qux'); return null }),
+    precall: mock.fn(() => {
+      sequence.push('qux')
+      return null
+    }),
     settle: mock.fn(),
     dispose: mock.fn()
   },
@@ -34,7 +40,10 @@ const families: Array<DirectiveFamily> = [
     mandatory: false,
     create: mock.fn((_0: string, _1: any, _2: any) => generate() as any),
     arrange: mock.fn(),
-    precall: mock.fn(() => { sequence.push('bar'); return null }),
+    precall: mock.fn(() => {
+      sequence.push('bar')
+      return null
+    }),
     settle: mock.fn(),
     dispose: mock.fn()
   }
@@ -49,11 +58,18 @@ beforeEach(() => {
   for (const family of families) {
     assert.ok(family.precall !== undefined)
 
-    family.precall.mock.mockImplementation(() => { sequence.push(family.name); return null })
+    family.precall.mock.mockImplementation(() => {
+      sequence.push(family.name)
+      return null
+    })
   }
 
-  factory = new DirectivesFactory(families, {} as unknown as Remotes, {} as unknown as Host,
-    { authorities: {} })
+  factory = new DirectivesFactory(
+    families,
+    {} as unknown as Remotes,
+    {} as unknown as Host,
+    { authorities: {} }
+  )
 })
 
 it('should create directive', async () => {
@@ -95,8 +111,11 @@ it('should throw error if directive family is not found', async () => {
     value: generate()
   }
 
-  assert.throws(() => factory.create([declaration]),
-    (error: Error) => error.message.includes(`Directive family '${declaration.family}' is not found`))
+  assert.throws(
+    () => factory.create([declaration]),
+    (error: Error) =>
+      error.message.includes(`Directive family '${declaration.family}' is not found`)
+  )
 })
 
 it('should apply directive', async () => {
@@ -129,7 +148,7 @@ it('should apply mandatory families', async () => {
 
 describe('order', () => {
   // the order the families actually ran, as each precall recorded it
-  function order (): string[] {
+  function order(): string[] {
     return sequence
   }
 
@@ -145,18 +164,17 @@ describe('order', () => {
     assert.deepStrictEqual(order(), ['foo', 'qux'])
   })
 
-  it('should run a mandatory family before a declared one it is not declared with',
-    async () => {
-      // only `qux` is declared: `foo` still has to run first, not merely first of
-      // whatever had no declarations
-      const directives = factory.create([
-        { family: 'qux', name: generate(), value: generate() }
-      ])
+  it('should run a mandatory family before a declared one it is not declared with', async () => {
+    // only `qux` is declared: `foo` still has to run first, not merely first of
+    // whatever had no declarations
+    const directives = factory.create([
+      { family: 'qux', name: generate(), value: generate() }
+    ])
 
-      await directives.precall(generate() as unknown as Context, [])
+    await directives.precall(generate() as unknown as Context, [])
 
-      assert.deepStrictEqual(order(), ['foo', 'qux'])
-    })
+    assert.deepStrictEqual(order(), ['foo', 'qux'])
+  })
 
   it('should run mandatory families before the rest', async () => {
     const directives = factory.create([
@@ -170,7 +188,7 @@ describe('order', () => {
   })
 })
 
-function resetCalls (target = [families], seen = new Set()) {
+function resetCalls(target = [families], seen = new Set()) {
   if (target === null || typeof target !== 'object' || seen.has(target)) return
 
   seen.add(target)

package/source/Directive.ts

@@ -12,7 +12,7 @@ export class Directives implements RTD.Directives {
   /** the span of a stage depends only on the set, so it is built once per route */
   private readonly spans: Spans[]
 
-  public constructor (sets: RTD.DirectiveSet[]) {
+  public constructor(sets: RTD.DirectiveSet[]) {
     this.sets = sets
     this.spans = sets.map((set) => ({
       precall: options(set, 'precall'),
@@ -21,29 +21,29 @@ export class Directives implements RTD.Directives {
     }))
   }
 
-  public declared<T> (family: string): T[] | undefined {
-    return this.sets.find((set) => set.family.name === family)?.directives as T[] | undefined
+  public declared<T>(family: string): T[] | undefined {
+    return this.sets.find((set) => set.family.name === family)?.directives as
+      | T[]
+      | undefined
   }
 
-  public async precall (context: Context, parameters: RTD.Parameter[]): Promise<Output> {
+  public async precall(context: Context, parameters: RTD.Parameter[]): Promise<Output> {
     let output = null
 
     for (let i = 0; i < this.sets.length; i++) {
       const set = this.sets[i]
 
-      if (set.family.precall === undefined)
-        continue
+      if (set.family.precall === undefined) continue
 
-      const out = await console.span(this.spans[i].precall,
-        async () => await set.family.precall!(set.directives, context, parameters))
+      const out = await console.span(
+        this.spans[i].precall,
+        async () => await set.family.precall!(set.directives, context, parameters)
+      )
 
-      if (out === null)
-        continue
+      if (out === null) continue
 
-      if (output !== null)
-        throw new Error('Multiple precall directives responded')
-      else
-        output = out
+      if (output !== null) throw new Error('Multiple precall directives responded')
+      else output = out
     }
 
     return output
@@ -54,21 +54,23 @@ export class Directives implements RTD.Directives {
    * what the one before it returned, and the first to refuse ends it: a method this caller
    * cannot reach is not described at all.
    */
-  public async explain (context: Context,
-    introspection: Introspection): Promise<Introspection | null> {
+  public async explain(
+    context: Context,
+    introspection: Introspection
+  ): Promise<Introspection | null> {
     let described: Introspection = introspection
 
     for (let i = 0; i < this.sets.length; i++) {
       const set = this.sets[i]
 
-      if (set.family.explain === undefined)
-        continue
+      if (set.family.explain === undefined) continue
 
-      const next = await console.span(this.spans[i].explain,
-        async () => await set.family.explain!(set.directives, context, described))
+      const next = await console.span(
+        this.spans[i].explain,
+        async () => await set.family.explain!(set.directives, context, described)
+      )
 
-      if (next === null)
-        return null
+      if (next === null) return null
 
       described = next
     }
@@ -76,19 +78,20 @@ export class Directives implements RTD.Directives {
     return described
   }
 
-  public async settle (context: Context, response: OutgoingMessage): Promise<void> {
+  public async settle(context: Context, response: OutgoingMessage): Promise<void> {
     for (let i = 0; i < this.sets.length; i++) {
       const set = this.sets[i]
 
       if (set.family.settle !== undefined)
-        await console.span(this.spans[i].settle,
-          async () => await set.family.settle!(set.directives, context, response))
+        await console.span(
+          this.spans[i].settle,
+          async () => await set.family.settle!(set.directives, context, response)
+        )
     }
   }
 
-  public dispose (): void {
-    for (const set of this.sets)
-      set.family.dispose?.(set.directives)
+  public dispose(): void {
+    for (const set of this.sets) set.family.dispose?.(set.directives)
   }
 }
 
@@ -102,14 +105,17 @@ export class DirectivesFactory implements RTD.DirectiveFactory {
   private readonly stages: Stage[] = []
 
   // eslint-disable-next-line max-params
-  public constructor (families: RTD.DirectiveFamily[], remotes: Remotes, host: Host,
-    options: Options) {
+  public constructor(
+    families: RTD.DirectiveFamily[],
+    remotes: Remotes,
+    host: Host,
+    options: Options
+  ) {
     for (const family of families) {
       family.mount?.(host, options)
       this.families[family.name] = family
 
-      if (family.mandatory)
-        this.mandatory.push(family.name)
+      if (family.mandatory) this.mandatory.push(family.name)
 
       this.stages.push({
         family,
@@ -125,22 +131,24 @@ export class DirectivesFactory implements RTD.DirectiveFactory {
    * Request-scoped, before anything is routed, so no directives are passed: a family
    * answers here only for what it does on its own behalf.
    */
-  public async preflight (context: Context): Promise<void> {
+  public async preflight(context: Context): Promise<void> {
     for (const stage of this.stages)
       if (stage.family.preflight !== undefined)
-        await console.span(stage.preflight,
-          async () => { await stage.family.preflight!(context) })
+        await console.span(stage.preflight, async () => {
+          await stage.family.preflight!(context)
+        })
   }
 
   /** Request-scoped, on the message going back. */
-  public async depart (context: Context, response: OutgoingMessage): Promise<void> {
+  public async depart(context: Context, response: OutgoingMessage): Promise<void> {
     for (const stage of this.stages)
       if (stage.family.depart !== undefined)
-        await console.span(stage.depart,
-          async () => { await stage.family.depart!(context, response) })
+        await console.span(stage.depart, async () => {
+          await stage.family.depart!(context, response)
+        })
   }
 
-  public create (declarations: RTD.syntax.Directive[], route: string = ''): Directives {
+  public create(declarations: RTD.syntax.Directive[], route: string = ''): Directives {
     const groups: Record<string, any> = {}
     const mandatory = new Set(this.mandatory)
 
@@ -152,7 +160,12 @@ export class DirectivesFactory implements RTD.DirectiveFactory {
       if (family === undefined)
         throw new Error(`Directive family '${declaration.family}' is not found`)
 
-      const directive = family.create(declaration.name, declaration.value, this.remotes, route)
+      const directive = family.create(
+        declaration.name,
+        declaration.value,
+        this.remotes,
+        route
+      )
 
       groups[family.name] ??= []
       groups[family.name].push(directive)
@@ -184,8 +197,7 @@ export class DirectivesFactory implements RTD.DirectiveFactory {
     sets.sort((a, b) => this.rank(a.family.name) - this.rank(b.family.name))
 
     // whatever order a family needs among its own directives is fixed here, not per request
-    for (const set of sets)
-      set.family.arrange?.(set.directives)
+    for (const set of sets) set.family.arrange?.(set.directives)
 
     const directives = new Directives(sets)
 
@@ -194,20 +206,22 @@ export class DirectivesFactory implements RTD.DirectiveFactory {
     return directives
   }
 
-  public dispose (): void {
-    for (const directives of this.instances)
-      directives.dispose()
+  public dispose(): void {
+    for (const directives of this.instances) directives.dispose()
   }
 
   /** Mandatory families first, in their own order; everything else keeps its own. */
-  private rank (family: string): number {
+  private rank(family: string): number {
     const index = this.mandatory.indexOf(family)
 
     return index === -1 ? this.mandatory.length : index
   }
 }
 
-function options (set: RTD.DirectiveSet, stage: 'precall' | 'settle' | 'explain'): SpanOptions {
+function options(
+  set: RTD.DirectiveSet,
+  stage: 'precall' | 'settle' | 'explain'
+): SpanOptions {
   const options: SpanOptions = { name: `${set.family.name} ${stage}` }
 
   if (set.names !== undefined && set.names.length > 0)

package/source/Endpoint.test.ts

@@ -10,7 +10,7 @@ import type { Parameter } from './RTD/index.js'
  * What `Remote.explain` answers is the contract's own object, the same one every time and
  * on every route that mounts the endpoint — which is what this stands in for.
  */
-function remote (): Promise<Remote> {
+function remote(): Promise<Remote> {
   const explanation = {
     input: {
       type: 'object',