@toa.io/extensions.exposition 1.0.0-alpha.291 → 1.0.0-alpha.293

package/schemas/node.cos.yaml

@@ -1,22 +0,0 @@
-properties:
-  protected:
-    type: boolean
-  isolated:
-    type: boolean
-  forward:
-    type: string
-  routes:
-    type: array
-    items:
-      $ref: route
-  methods:
-    type: array
-    items:
-      $ref: method
-  directives:
-    type: array
-    items:
-      $ref: directive
-  version:
-    type: string
-type: object

package/schemas/query.cos.yaml

@@ -1,31 +0,0 @@
-properties:
-  id:
-    type: string
-  criteria:
-    type: string
-  sort:
-    type: string
-  search:
-    type: boolean
-  sample:
-    type: integer
-  omit:
-    $ref: range
-  limit:
-    $ref: range
-  selectors:
-    type: array
-    items:
-      type: string
-  projection:
-    type: array
-    items:
-      type: string
-  parameters:
-    type: array
-    items:
-      type: string
-  deleted:
-    type: boolean
-nullable: true
-type: object

package/schemas/querystring.cos.yaml

@@ -1,19 +0,0 @@
-properties:
-  id:
-    type: string
-  criteria:
-    type: string
-  search:
-    type: string
-  sample:
-    type: number
-  sort:
-    type: string
-  omit:
-    type: number
-  limit:
-    type: number
-  version:
-    type: number
-additionalProperties: false
-type: object

package/schemas/range.cos.yaml

@@ -1,10 +0,0 @@
-properties:
-  range:
-    type: array
-    items:
-      type: number
-  value:
-    type: number
-type: object
-required:
-  - range

package/schemas/route.cos.yaml

@@ -1,6 +0,0 @@
-properties:
-  path:
-    type: string
-  node:
-    $ref: node
-type: object

package/source/Annotation.ts

@@ -1,89 +0,0 @@
-import type { Resources } from '@toa.io/operations'
-import type { Protocol } from './HTTP/index.js'
-
-export interface Annotation {
-  authorities: Record<string, string>
-
-  /**
-   * `h2c` requires an ingress controller that proxies cleartext HTTP/2 upstream.
-   * See `documentation/protocol.md`.
-   */
-  protocol?: Protocol
-  class?: string
-  resources?: Resources
-  annotations?: Record<string, string>
-
-  /** The Service, as opposed to the Ingress that `annotations` above describes. */
-  service?: { annotations?: Record<string, string> }
-
-  debug?: boolean
-
-  /** The header the client address is read from; the connection's without one. See `ip.md`. */
-  ip?: string
-
-  /** Failed authentications an address may make; none are metered unless set. See `identity.md`. */
-  bouncer?: Bouncer
-
-  /** The authorization server this context exposes; none is exposed without it. */
-  oauth?: OAuth
-
-  /** JSON-RPC at `/.rpc`; none is served without it. See `documentation/rpc.md`. */
-  rpc?: RPC
-
-  /** MCP at `/.mcp`; none is served without it. See `documentation/mcp.md`. */
-  mcp?: MCP
-  '/'?: object // parsed and validated by RTD.syntax.parse
-}
-
-export interface OAuth {
-  /**
-   * Where a client sends the user to consent. The one endpoint of the flow that needs a
-   * person, and so the one this extension does not serve: an application builds it.
-   */
-  authorize: string
-
-  /** Paths a token may be restricted to, each advertised as a protected resource. */
-  resources?: string[]
-
-  /** What a client may ask for. Each is a role, or a scope within one. */
-  scopes?: string[]
-
-  /** Origins whose Client ID Metadata Documents may be read. None are without it. */
-  trust?: string[]
-
-  /** Dynamic Client Registration, off unless opened. */
-  registration?: 'open' | 'closed'
-}
-
-export interface RPC {
-  /**
-   * Calls one request may carry, 32 by default. One request is one authentication and one
-   * reply however many calls it makes, so what a caller may ask for at once is bounded.
-   */
-  batch?: number
-}
-
-export interface MCP {
-  /** What the server calls itself, which a client shows a user. */
-  name: string
-
-  /** What a model is told before it calls anything here. */
-  instructions?: string
-
-  /**
-   * Browser origins the endpoint answers, which the revision requires against DNS rebinding.
-   * None are admitted without it; a request carrying no `Origin` is not a browser's.
-   */
-  origins?: string[]
-
-  /** Whether the endpoint answers without a credential. It does not unless it says so. */
-  anonymous?: boolean
-}
-
-export interface Bouncer {
-  /** what an address may fail at once, 20 by default */
-  attempts?: number
-
-  /** seconds it takes to earn them back, 60 by default */
-  interval?: number
-}

package/source/Branch.test.ts

@@ -1,40 +0,0 @@
-import { it } from 'node:test'
-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 {
-  return {
-    namespace: 'default',
-    component: 'one',
-    isolated: false,
-    node: { routes: [], methods: [], directives: [] },
-    version,
-    timestamp
-  }
-}
-
-function exposed(version: string, timestamp: number): Exposed {
-  return { version, timestamp, nodes: [] }
-}
-
-it('should refresh the same version', () => {
-  assert.deepStrictEqual(decide(exposed('a', 1), branch('a', 2)), 'refresh')
-})
-
-it('should refresh the same version announced by an older tenant', () => {
-  assert.deepStrictEqual(decide(exposed('a', 2), branch('a', 1)), 'refresh')
-})
-
-it('should merge a newer tenant', () => {
-  assert.deepStrictEqual(decide(exposed('a', 1), branch('b', 2)), 'merge')
-})
-
-it('should not merge a tenant that started earlier', () => {
-  assert.deepStrictEqual(decide(exposed('b', 2), branch('a', 1)), 'superseded')
-})
-
-it('should merge when tenants started at the same time', () => {
-  assert.deepStrictEqual(decide(exposed('a', 1), branch('b', 1)), 'merge')
-})

package/source/Branch.ts

@@ -1,44 +0,0 @@
-import type * as RTD from './RTD/syntax/index.js'
-import type { Node } from './RTD/index.js'
-
-export interface Branch {
-  namespace: string
-  component: string
-  isolated: boolean
-  node: RTD.Node
-  version: string
-
-  /**
-   * When the tenant that announced it started, by its own clock. A replica on its way
-   * out announces the same component with an older stamp than the one replacing it, and
-   * that is what tells the two apart when their versions differ.
-   */
-  timestamp: number
-}
-
-/** A branch the gateway has merged, and the tenant it came from. */
-export interface Exposed {
-  version: string
-
-  /** The start time of the tenant this branch came from. */
-  timestamp: number
-
-  nodes: Node[]
-}
-
-/**
- * What to do with an announcement about a component that already has a branch exposed.
- *
- * - `refresh`: the same version, so its expiration is extended and its endpoints left alone
- * - `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'
-
-  if (branch.timestamp < exposed.timestamp) return 'superseded'
-
-  return 'merge'
-}
-
-export type Decision = 'merge' | 'refresh' | 'superseded'

package/source/Composition.ts

@@ -1,51 +0,0 @@
-import { readdirSync, type Dirent } from 'node:fs'
-import { resolve } from 'node:path'
-import { Connector } from '@toa.io/core'
-import { type Host } from './Factory.js'
-
-export class Composition extends Connector {
-  private readonly host: Host
-
-  public constructor(host: Host) {
-    super()
-    this.host = host
-  }
-
-  protected override async open(): Promise<void> {
-    const paths = find()
-    const composition = await this.host.composition(paths)
-
-    await composition.connect()
-
-    this.depends(composition)
-  }
-}
-
-function find(): string[] {
-  return entries().map((entry) => resolve(ROOT, entry.name))
-}
-
-function entries(): Dirent[] {
-  const entries = readdirSync(ROOT, { withFileTypes: true })
-
-  return entries.filter((entry) => entry.isDirectory())
-}
-
-export function components(): Components {
-  const labels: string[] = []
-  const paths: string[] = []
-
-  for (const entry of entries()) {
-    labels.push(entry.name.replace('.', '-'))
-    paths.push(resolve(ROOT, entry.name))
-  }
-
-  return { labels, paths }
-}
-
-interface Components {
-  labels: string[]
-  paths: string[]
-}
-
-const ROOT = resolve(import.meta.dirname, '../components/')

package/source/Context.ts

@@ -1,11 +0,0 @@
-import type * as RTD from './RTD/index.js'
-
-// the trunk is built from the context annotation and belongs to no branch,
-// thus its endpoints must be fully qualified and are not versioned
-export type Context = RTD.Context<Extension | undefined>
-
-interface Extension {
-  namespace: string
-  component: string
-  version: string
-}

package/source/Directive.test.ts

@@ -1,199 +0,0 @@
-import { describe, it, beforeEach, mock } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { generate } from 'randomstring'
-import { DirectivesFactory } from './Directive.js'
-import type { syntax, DirectiveFamily } from './RTD/index.js'
-import type { Remotes } from './Remotes.js'
-import type { Host } from './Factory.js'
-import type { Context } from './HTTP/index.js'
-
-const sequence: string[] = []
-
-const families: Array<DirectiveFamily> = [
-  {
-    name: 'foo',
-    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
-    }),
-    settle: mock.fn(),
-    dispose: mock.fn()
-  },
-  {
-    name: 'qux',
-    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
-    }),
-    settle: mock.fn(),
-    dispose: mock.fn()
-  },
-  {
-    name: 'bar',
-    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
-    }),
-    settle: mock.fn(),
-    dispose: mock.fn()
-  }
-]
-
-let factory: DirectivesFactory
-
-beforeEach(() => {
-  resetCalls()
-  sequence.length = 0
-
-  for (const family of families) {
-    assert.ok(family.precall !== undefined)
-
-    family.precall.mock.mockImplementation(() => {
-      sequence.push(family.name)
-      return null
-    })
-  }
-
-  factory = new DirectivesFactory(
-    families,
-    {} as unknown as Remotes,
-    {} as unknown as Host,
-    { authorities: {} }
-  )
-})
-
-it('should create directive', async () => {
-  const declarations: syntax.Directive[] = [
-    {
-      family: 'foo',
-      name: generate(),
-      value: generate()
-    },
-    {
-      family: 'bar',
-      name: generate(),
-      value: generate()
-    }
-  ]
-
-  factory.create(declarations)
-
-  for (const declaration of declarations) {
-    const family = families.find(({ name }) => name === declaration.family)!
-
-    assert.strictEqual(family.create.mock.calls[0].arguments[0], declaration.name)
-    assert.strictEqual(family.create.mock.calls[0].arguments[1], declaration.value)
-  }
-})
-
-it('should pass the route to the families', async () => {
-  const route = '/' + generate()
-
-  factory.create([{ family: 'foo', name: generate(), value: generate() }], route)
-
-  assert.strictEqual(families[0].create.mock.calls[0].arguments[3], route)
-})
-
-it('should throw error if directive family is not found', async () => {
-  const declaration: syntax.Directive = {
-    family: generate(),
-    name: generate(),
-    value: generate()
-  }
-
-  assert.throws(
-    () => factory.create([declaration]),
-    (error: Error) =>
-      error.message.includes(`Directive family '${declaration.family}' is not found`)
-  )
-})
-
-it('should apply directive', async () => {
-  const declaration: syntax.Directive = {
-    family: 'foo',
-    name: generate(),
-    value: generate()
-  }
-
-  const directives = factory.create([declaration])
-  const request = generate() as unknown as Context
-  const directive = families[0].create.mock.calls[0].result
-
-  await directives.precall(request, [])
-
-  assert.ok(families[0].precall !== undefined)
-
-  assert.deepStrictEqual(families[0].precall.mock.calls[0].arguments[0], [directive])
-  assert.deepStrictEqual(families[0].precall.mock.calls[0].arguments[1], request)
-})
-
-it('should apply mandatory families', async () => {
-  const directives = factory.create([])
-  const request = generate() as unknown as Context
-
-  await directives.precall(request, [])
-
-  assert.ok(families[0].precall.mock.callCount() > 0)
-})
-
-describe('order', () => {
-  // the order the families actually ran, as each precall recorded it
-  function order(): string[] {
-    return sequence
-  }
-
-  it('should run mandatory families in their own order, whatever a manifest says', async () => {
-    // `qux` declared first, but `foo` is registered first and both are mandatory
-    const directives = factory.create([
-      { family: 'qux', name: generate(), value: generate() },
-      { family: 'foo', name: generate(), value: generate() }
-    ])
-
-    await directives.precall(generate() as unknown as Context, [])
-
-    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() }
-    ])
-
-    await directives.precall(generate() as unknown as Context, [])
-
-    assert.deepStrictEqual(order(), ['foo', 'qux'])
-  })
-
-  it('should run mandatory families before the rest', async () => {
-    const directives = factory.create([
-      { family: 'bar', name: generate(), value: generate() },
-      { family: 'qux', name: generate(), value: generate() }
-    ])
-
-    await directives.precall(generate() as unknown as Context, [])
-
-    assert.deepStrictEqual(order(), ['foo', 'qux', 'bar'])
-  })
-})
-
-function resetCalls(target = [families], seen = new Set()) {
-  if (target === null || typeof target !== 'object' || seen.has(target)) return
-
-  seen.add(target)
-
-  for (const value of Object.values(target))
-    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
-    else resetCalls(value, seen)
-}