@toa.io/extensions.exposition 1.0.0-alpha.3 → 1.0.0-alpha.300

package/features/steps/components/pots/manifest.toa.yaml

@@ -1,20 +0,0 @@
-name: pots
-
-entity:
-  schema:
-    title: string
-    volume: number
-    temperature?: number
-
-operations:
-  transit:
-    query: false
-    input:
-      title*: ~
-      volume*: ~
-  observe:
-    output:
-      id: string
-      title: string
-      volume: number
-      temperature: number

package/features/steps/components/sequences/manifest.toa.yaml

@@ -1,10 +0,0 @@
-name: sequences
-
-operations:
-  numbers:
-    input: 5
-
-exposition:
-  /tokens:
-    anonymous: true
-    GET: tokens

package/features/steps/components/sequences/operations/numbers.js

@@ -1,7 +0,0 @@
-'use strict'
-
-function * effect (amount) {
-  for (let i = 0; i < amount; i++) yield i
-}
-
-exports.effect = effect

package/features/steps/components/sequences/operations/tokens.js

@@ -1,16 +0,0 @@
-'use strict'
-
-const { randomBytes } = require('node:crypto')
-
-async function * computation () {
-  while (true) {
-    await timeout(Math.floor(Math.random() * 100) + 10)
-    yield randomBytes(4).toString('hex')
-  }
-}
-
-function timeout (ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
-}
-
-exports.computation = computation

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

@@ -1,14 +0,0 @@
-name: users
-
-entity:
-  schema:
-    name: string
-
-operations:
-  transit:
-    concurrency: retry
-    input:
-      name*: ~
-  create:
-    query: false
-    forward: transit

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

@@ -1,13 +0,0 @@
-namespace: users
-name: properties
-
-entity:
-  schema:
-    newbie: false
-  dependent: true
-
-operations:
-  transit:
-    concurrency: retry
-    input:
-      newbie*: .

package/features/steps/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "noEmit": true,
-    "moduleResolution": "node",
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
-  }
-}

package/features/streams.feature

@@ -1,30 +0,0 @@
-Feature: Reply streams
-
-  Scenario: Getting a Reply stream
-    Given the `sequences` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          POST: numbers
-      """
-    When the following request is received:
-      """
-      POST /sequences/ HTTP/1.1
-      content-type: text/plain
-      accept: text/plain
-
-      3
-      """
-    Then the following reply is sent:
-      """
-      201 Created
-      content-type: multipart/text; boundary=cut
-
-      --cut
-      0
-      --cut
-      1
-      --cut
-      2
-      --cut--
-      """

package/features/vary.feature

@@ -1,150 +0,0 @@
-Feature: The Vary directive family
-
-  Scenario Outline: Embedding a `<result>` language code
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          vary:languages: [en, fr]
-          GET:
-            vary:embed:
-              name: language  # embed resolved language code as a `name` property of the operation input
-            endpoint: compute
-      """
-    When the following request is received:
-      """
-      GET /echo/ HTTP/1.1
-      accept: application/yaml
-      accept-language: <accept>
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      content-type: application/yaml
-      content-language: <result>
-      vary: accept-language, accept
-
-      Hello <result>
-      """
-    Examples:
-      | accept | result |
-      | en     | en     |
-      | en_US  | en     |
-      | fr     | fr     |
-      | sw     | en     |
-
-  Scenario: Listing languages on the root
-    Given the annotation:
-    """
-    /:
-      vary:languages: [en, fr]
-    """
-    And the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          GET:
-            anonymous: true
-            vary:embed:
-              name: language
-            endpoint: compute
-      """
-    When the following request is received:
-      """
-      GET /echo/ HTTP/1.1
-      accept: application/yaml
-      accept-language: fr
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      content-type: application/yaml
-      content-language: fr
-      """
-
-
-  Scenario: Embedding a value of an arbitrary header
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          GET:
-            vary:embed:
-              name: :foo
-            endpoint: compute
-      """
-    When the following request is received:
-      """
-      GET /echo/ HTTP/1.1
-      accept: application/yaml
-      foo: bar
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      content-type: application/yaml
-      vary: foo, accept
-
-      Hello bar
-      """
-
-  Scenario Outline: Embedding a value from the list of options
-    Given the `echo` is running with the following manifest:
-        """yaml
-        exposition:
-          /:
-            vary:languages: [en, fr]
-            GET:
-              vary:embed:
-                name:
-                  - :foo
-                  - :bar
-                  - language
-              endpoint: compute
-        """
-    When the following request is received:
-        """
-        GET /echo/ HTTP/1.1
-        accept: application/yaml
-        <header>: <value>
-        """
-    Then the following reply is sent:
-        """
-        200 OK
-        content-type: application/yaml
-        vary: <header>, accept
-
-        Hello <value>
-        """
-    Examples:
-      | header          | value |
-      | foo             | bar   |
-      | bar             | baz   |
-      | accept-language | en    |
-
-  Scenario: Adding headers used by defined embeddings to CORS permissions
-    Given the `echo` is running with the following manifest:
-        """yaml
-        exposition:
-          /:
-            vary:languages: [en, fr]
-            GET:
-              vary:embed:
-                name:
-                  - language
-                  - :foo
-                  - :FOO
-                  - :bar
-              endpoint: compute
-        """
-    When the following request is received:
-        """
-        OPTIONS / HTTP/1.1
-        origin: http://example.com
-        access-control-request-headers: whatever
-        """
-    Then the following reply is sent:
-        """
-        204 No Content
-        access-control-allow-headers: accept, authorization, content-type, accept-language, foo, bar
-        """

package/schemas/annotation.cos.yaml

@@ -1,5 +0,0 @@
-host: string
-class: string
-annotations: <string>
-debug: boolean
-/: ~

package/schemas/directive.cos.yaml

@@ -1,3 +0,0 @@
-family: string
-name: string
-value: ~

package/schemas/method.cos.yaml

@@ -1,8 +0,0 @@
-verb: /^(GET|POST|PUT|PATCH|DELETE)$/
-mapping:
-  namespace: string
-  component: string
-  endpoint: string
-  query:
-    $ref: query
-directives: [ref:directive]

package/schemas/node.cos.yaml

@@ -1,5 +0,0 @@
-protected: boolean
-isolated: boolean
-routes: [ref:route]
-methods: [ref:method]
-directives: [ref:directive]

package/schemas/octets/context.cos.yaml

@@ -1 +0,0 @@
-string

package/schemas/octets/fetch.cos.yaml

@@ -1,3 +0,0 @@
-blob: boolean
-meta: boolean
-_: true

package/schemas/octets/list.cos.yaml

@@ -1,2 +0,0 @@
-meta: boolean
-_: true

package/schemas/octets/permute.cos.yaml

@@ -1 +0,0 @@
-~

package/schemas/octets/store.cos.yaml

@@ -1,3 +0,0 @@
-accept+: string
-workflow+: <string>
-_: true

package/schemas/query.cos.yaml

@@ -1,17 +0,0 @@
-_: true
-id?: string
-criteria?: string
-sort?: string
-omit:
-  $ref: range
-  default:
-    value: 0
-    range: [0, 1000]
-limit:
-  $ref: range
-  default:
-    value: 10
-    range: [1, 1000]
-  required: [value]
-selectors?: [string]
-projection?: [string]

package/schemas/querystring.cos.yaml

@@ -1,5 +0,0 @@
-id: string
-criteria: string
-sort: string
-omit: number
-limit: number

package/schemas/range.cos.yaml

@@ -1,2 +0,0 @@
-value?: number
-range: [number]

package/schemas/route.cos.yaml

@@ -1,2 +0,0 @@
-path: string
-node: ref:node

package/source/Annotation.ts

@@ -1,7 +0,0 @@
-export interface Annotation {
-  host?: string
-  class?: string
-  annotations?: Record<string, string>
-  debug: boolean
-  '/'?: object // parsed and validated by RTD.syntax.parse
-}

package/source/Branch.ts

@@ -1,8 +0,0 @@
-import type * as RTD from './RTD/syntax'
-
-export interface Branch {
-  namespace: string
-  component: string
-  isolated: boolean
-  node: RTD.Node
-}

package/source/Composition.ts

@@ -1,57 +0,0 @@
-import { readdirSync, type Dirent } from 'node:fs'
-import { resolve } from 'node:path'
-import { Connector } from '@toa.io/core'
-import { type Bootloader } from './Factory'
-
-export class Composition extends Connector {
-  private readonly boot: Bootloader
-
-  public constructor (boot: Bootloader) {
-    super()
-    this.boot = boot
-  }
-
-  protected override async open (): Promise<void> {
-    const paths = find()
-    const composition = await this.boot.composition(paths)
-
-    await composition.connect()
-
-    this.depends(composition)
-
-    console.info('Composition complete.')
-  }
-
-  protected override dispose (): void {
-    console.info('Composition shutdown complete.')
-  }
-}
-
-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(__dirname, '../components/')

package/source/Context.ts

@@ -1,6 +0,0 @@
-import { type Endpoint } from './Endpoint'
-import { type Directives } from './Directive'
-import { type Branch } from './Branch'
-import type * as RTD from './RTD'
-
-export type Context = RTD.Context<Endpoint, Directives, Branch>

package/source/Directive.test.ts

@@ -1,97 +0,0 @@
-import assert from 'node:assert'
-import { generate } from 'randomstring'
-import { DirectivesFactory, type Family } from './Directive'
-import { type syntax } from './RTD'
-import { type IncomingMessage } from './HTTP'
-import { type Remotes } from './Remotes'
-
-const families: Array<jest.MockedObjectDeep<Family>> = [
-  {
-    name: 'foo',
-    mandatory: true,
-    create: jest.fn((_0: any, _1: any, _2: any) => generate() as any),
-    preflight: jest.fn(),
-    settle: jest.fn()
-  },
-  {
-    name: 'bar',
-    mandatory: false,
-    create: jest.fn((_0: string, _1: any, _2: any) => generate() as any),
-    preflight: jest.fn(),
-    settle: jest.fn()
-  }
-]
-
-let factory: DirectivesFactory
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  assert.ok(families[0].preflight !== undefined)
-  assert.ok(families[1].preflight !== undefined)
-
-  families[0].preflight.mockImplementation(() => null)
-  families[1].preflight.mockImplementation(() => null)
-  factory = new DirectivesFactory(families, {} as unknown as Remotes)
-})
-
-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 (let i = 0; i < declarations.length; i++) {
-    expect(families[i].create.mock.calls[0][0]).toBe(declarations[i].name)
-    expect(families[i].create.mock.calls[0][1]).toBe(declarations[i].value)
-  }
-})
-
-it('should throw error if directive family is not found', async () => {
-  const declaration: syntax.Directive = {
-    family: generate(),
-    name: generate(),
-    value: generate()
-  }
-
-  expect(() => factory.create([declaration]))
-    .toThrowError(`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 IncomingMessage
-  const directive = families[0].create.mock.results[0].value
-
-  await directives.preflight(request, [])
-
-  assert.ok(families[0].preflight !== undefined)
-
-  expect(families[0].preflight.mock.calls[0][0]).toStrictEqual([directive])
-  expect(families[0].preflight.mock.calls[0][1]).toEqual(request)
-})
-
-it('should apply mandatory families', async () => {
-  const directives = factory.create([])
-  const request = generate() as unknown as IncomingMessage
-
-  await directives.preflight(request, [])
-
-  expect(families[0].preflight).toHaveBeenCalled()
-})

package/source/Directive.ts

@@ -1,123 +0,0 @@
-import type { IncomingMessage, OutgoingMessage } from './HTTP'
-import type { Remotes } from './Remotes'
-import type { Output } from './io'
-import type * as RTD from './RTD'
-
-export class Directives implements RTD.Directives<Directives> {
-  private readonly sets: DirectiveSet[]
-
-  public constructor (sets: DirectiveSet[]) {
-    this.sets = sets
-  }
-
-  public async preflight (request: IncomingMessage, parameters: RTD.Parameter[]): Promise<Output> {
-    for (const set of this.sets) {
-      if (set.family.preflight === undefined)
-        continue
-
-      const output = await set.family.preflight(set.directives, request, parameters)
-
-      if (output !== null) {
-        await this.settle(request, output)
-
-        return output
-      }
-    }
-
-    return null
-  }
-
-  public async settle (request: IncomingMessage, response: OutgoingMessage): Promise<void> {
-    for (const set of this.sets)
-      if (set.family.settle !== undefined)
-        await set.family.settle(set.directives, request, response)
-  }
-
-  public merge (directives: Directives): void {
-    this.sets.push(...directives.sets)
-  }
-}
-
-export class DirectivesFactory implements RTD.DirectivesFactory<Directives> {
-  private readonly remtoes: Remotes
-  private readonly families: Record<string, Family> = {}
-  private readonly mandatory: string[] = []
-
-  public constructor (families: Family[], remotes: Remotes) {
-    for (const family of families) {
-      this.families[family.name] = family
-
-      if (family.mandatory)
-        this.mandatory.push(family.name)
-    }
-
-    this.remtoes = remotes
-  }
-
-  public create (declarations: RTD.syntax.Directive[]): Directives {
-    const groups: Record<string, any> = {}
-    const mandatory = new Set(this.mandatory)
-
-    declarations.sort((a, b) =>
-      (mandatory.has(b.family) ? 1 : 0) - (mandatory.has(a.family) ? 1 : 0))
-
-    for (const declaration of declarations) {
-      const family = this.families[declaration.family]
-
-      if (family === undefined)
-        throw new Error(`Directive family '${declaration.family}' is not found.`)
-
-      const directive = family.create(declaration.name, declaration.value, this.remtoes)
-
-      groups[family.name] ??= []
-      groups[family.name].push(directive)
-      mandatory.delete(family.name)
-    }
-
-    const sets: DirectiveSet[] = []
-
-    for (const family of mandatory)
-      sets.push({
-        family: this.families[family],
-        directives: []
-      })
-
-    for (const [family, directives] of Object.entries(groups))
-      sets.push({
-        family: this.families[family],
-        directives
-      })
-
-    return new Directives(sets)
-  }
-}
-
-export const shortcuts: RTD.syntax.Shortcuts = new Map([
-  ['anonymous', 'auth:anonymous'],
-  ['id', 'auth:id'],
-  ['role', 'auth:role'],
-  ['rule', 'auth:rule'],
-  ['incept', 'auth:incept']
-])
-
-export interface Family<TDirective = any, TExtension = any> {
-  readonly name: string
-  readonly mandatory: boolean
-
-  // produce: (declarations: RTD.syntax.Directive[], remotes: Remotes) => TDirective[]
-
-  create: (name: string, value: any, remotes: Remotes) => TDirective
-
-  preflight?: (directives: TDirective[],
-    request: IncomingMessage & TExtension,
-    parameters: RTD.Parameter[]) => Output | Promise<Output>
-
-  settle?: (directives: TDirective[],
-    request: IncomingMessage & TExtension,
-    response: OutgoingMessage) => void | Promise<void>
-}
-
-interface DirectiveSet {
-  family: Family
-  directives: any[]
-}