@toa.io/extensions.exposition 0.24.0-alpha.9 → 1.0.0-alpha.2

package/features/vary.feature

@@ -0,0 +1,150 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/extensions.exposition",
-  "version": "0.24.0-alpha.9",
+  "version": "1.0.0-alpha.2",
   "description": "Toa Exposition",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -17,17 +17,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@toa.io/core": "0.24.0-alpha.9",
-    "@toa.io/generic": "0.24.0-alpha.9",
-    "@toa.io/schemas": "0.24.0-alpha.9",
-    "@toa.io/streams": "0.24.0-alpha.9",
+    "@toa.io/core": "1.0.0-alpha.2",
+    "@toa.io/generic": "1.0.0-alpha.2",
+    "@toa.io/schemas": "1.0.0-alpha.2",
+    "@toa.io/streams": "1.0.0-alpha.2",
     "bcryptjs": "2.4.3",
-    "cors": "2.8.5",
     "error-value": "0.3.0",
     "express": "4.18.2",
     "js-yaml": "4.1.0",
     "matchacho": "0.3.5",
-    "msgpackr": "1.9.5",
+    "msgpackr": "1.10.1",
     "negotiator": "0.6.3",
     "paseto": "3.1.4"
   },
@@ -37,21 +36,21 @@
   },
   "scripts": {
     "test": "jest",
-    "transpile": "npx tsc && npm run transpile:basic && npm run transpile:tokens && npm run transpile:roles",
-    "transpile:basic": "npx tsc -p ./components/identity.basic",
-    "transpile:tokens": "npx tsc -p ./components/identity.tokens",
-    "transpile:roles": "npx tsc -p ./components/identity.roles",
-    "features": "npx cucumber-js"
+    "transpile": "tsc && npm run transpile:basic && npm run transpile:tokens && npm run transpile:roles && npm run transpile:federation",
+    "transpile:basic": "tsc -p ./components/identity.basic",
+    "pretranspile:federation": "js-yaml components/identity.federation/manifest.toa.yaml | jq -M '{ type: \"object\", properties: {configuration: .configuration.schema, entity: .entity.schema }, additionalProperties: false}' > schemas.json && json2ts -i schemas.json -o components/identity.federation/source/schemas.ts && rm schemas.json",
+    "transpile:federation": "tsc -p ./components/identity.federation",
+    "transpile:tokens": "tsc -p ./components/identity.tokens",
+    "transpile:roles": "tsc -p ./components/identity.roles",
+    "features": "cucumber-js"
   },
   "devDependencies": {
-    "@toa.io/extensions.storages": "0.24.0-alpha.9",
-    "@toa.io/http": "0.24.0-alpha.9",
+    "@toa.io/agent": "1.0.0-alpha.2",
+    "@toa.io/extensions.storages": "1.0.0-alpha.2",
     "@types/bcryptjs": "2.4.3",
     "@types/cors": "2.8.13",
     "@types/express": "4.17.17",
-    "@types/fs-extra": "11.0.4",
-    "@types/negotiator": "0.6.1",
-    "fs-extra": "11.1.1"
+    "@types/negotiator": "0.6.1"
   },
-  "gitHead": "aaa343035500526a21666a4416ab76a445ab184d"
+  "gitHead": "7688e6e980a65c82ac2e459be4e355eebf406cd0"
 }

package/schemas/octets/delete.cos.yaml

@@ -1 +1,2 @@
-~
+workflow+: <string>
+_: true

package/schemas/octets/list.cos.yaml

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

package/source/Directive.test.ts

@@ -1,10 +1,11 @@
+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.MockedObject<Family>> = [
+const families: Array<jest.MockedObjectDeep<Family>> = [
   {
     name: 'foo',
     mandatory: true,
@@ -26,6 +27,9 @@ 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)
@@ -61,7 +65,7 @@ it('should throw error if directive family is not found', async () => {
   }
 
   expect(() => factory.create([declaration]))
-    .toThrowError(`Directive family '${declaration.family}' not found.`)
+    .toThrowError(`Directive family '${declaration.family}' is not found.`)
 })
 
 it('should apply directive', async () => {
@@ -77,6 +81,8 @@ it('should apply directive', async () => {
 
   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)
 })

package/source/Directive.ts

@@ -1,17 +1,21 @@
-import { type IncomingMessage, type OutgoingMessage } from './HTTP'
-import { type Remotes } from './Remotes'
+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 directives: DirectiveSet[]
+  private readonly sets: DirectiveSet[]
 
-  public constructor (directives: DirectiveSet[]) {
-    this.directives = directives
+  public constructor (sets: DirectiveSet[]) {
+    this.sets = sets
   }
 
   public async preflight (request: IncomingMessage, parameters: RTD.Parameter[]): Promise<Output> {
-    for (const directive of this.directives) {
-      const output = await directive.family.preflight(directive.directives, request, parameters)
+    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)
@@ -24,13 +28,13 @@ export class Directives implements RTD.Directives<Directives> {
   }
 
   public async settle (request: IncomingMessage, response: OutgoingMessage): Promise<void> {
-    for (const directive of this.directives)
-      if (directive.family.settle !== undefined)
-        await directive.family.settle(directive.directives, request, response)
+    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.directives.push(...directives.directives)
+    this.sets.push(...directives.sets)
   }
 }
 
@@ -61,7 +65,7 @@ export class DirectivesFactory implements RTD.DirectivesFactory<Directives> {
       const family = this.families[declaration.family]
 
       if (family === undefined)
-        throw new Error(`Directive family '${declaration.family}' not found.`)
+        throw new Error(`Directive family '${declaration.family}' is not found.`)
 
       const directive = family.create(declaration.name, declaration.value, this.remtoes)
 
@@ -100,9 +104,11 @@ 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[],
+  preflight?: (directives: TDirective[],
     request: IncomingMessage & TExtension,
     parameters: RTD.Parameter[]) => Output | Promise<Output>
 
@@ -115,6 +121,3 @@ interface DirectiveSet {
   family: Family
   directives: any[]
 }
-
-export type Input = IncomingMessage
-export type Output = OutgoingMessage | null

package/source/Factory.ts

@@ -4,19 +4,18 @@ import { Remotes } from './Remotes'
 import { Tree, syntax } from './RTD'
 import { Server } from './HTTP'
 import { type Endpoint, EndpointsFactory } from './Endpoint'
-import * as directives from './directives'
-import { type Directives, DirectivesFactory, type Family } from './Directive'
+import { families, interceptors } from './directives'
+import { type Directives, DirectivesFactory } from './Directive'
 import { Composition } from './Composition'
 import * as root from './root'
+import { Interception } from './Interception'
 import type { Connector, Locator, extensions } from '@toa.io/core'
 
 export class Factory implements extensions.Factory {
   private readonly boot: Bootloader
-  private readonly families: Family[]
 
   public constructor (boot: Bootloader) {
     this.boot = boot
-    this.families = directives.families
   }
 
   public tenant (locator: Locator, node: syntax.Node): Connector {
@@ -32,16 +31,18 @@ export class Factory implements extensions.Factory {
     const remotes = new Remotes(this.boot)
     const node = root.resolve()
     const methods = new EndpointsFactory(remotes)
-    const directives = new DirectivesFactory(this.families, remotes)
+    const directives = new DirectivesFactory(families, remotes)
+    const interception = new Interception(interceptors)
     const tree = new Tree<Endpoint, Directives>(node, methods, directives)
 
     const composition = new Composition(this.boot)
-    const gateway = new Gateway(broadcast, server, tree)
+    const gateway = new Gateway(broadcast, server, tree, interception)
 
     gateway.depends(remotes)
     gateway.depends(composition)
+    server.depends(gateway)
 
-    return gateway
+    return server
   }
 }
 

package/source/Gateway.ts

@@ -1,25 +1,31 @@
 import { type bindings, Connector } from '@toa.io/core'
-import { type Maybe } from '@toa.io/types'
 import * as http from './HTTP'
 import { rethrow } from './exceptions'
-import { type Method, type Parameter, type Tree } from './RTD'
-import { type Label } from './discovery'
-import { type Branch } from './Branch'
-import { type Endpoint } from './Endpoint'
-import { type Directives } from './Directive'
+import type { Interceptor } from './Interception'
+import type { Maybe } from '@toa.io/types'
+import type { Method, Parameter, Tree } from './RTD'
+import type { Label } from './discovery'
+import type { Branch } from './Branch'
+import type { Endpoint } from './Endpoint'
+import type { Directives } from './Directive'
 
 export class Gateway extends Connector {
   private readonly broadcast: Broadcast
   private readonly tree: Tree<Endpoint, Directives>
+  private readonly interceptor: Interceptor
+  private readonly server: Connector
 
-  public constructor (broadcast: Broadcast, server: http.Server, tree: Tree<Endpoint, Directives>) {
+  // eslint-disable-next-line max-params, max-len
+  public constructor (broadcast: Broadcast, server: http.Server, tree: Tree<Endpoint, Directives>, interception: Interceptor) {
     super()
 
     this.broadcast = broadcast
     this.tree = tree
+    this.interceptor = interception
+    this.server = server
 
     this.depends(broadcast)
-    this.depends(server)
+    // this.depends(server)
 
     server.attach(this.process.bind(this))
   }
@@ -35,6 +41,11 @@ export class Gateway extends Connector {
   }
 
   private async process (request: http.IncomingMessage): Promise<http.OutgoingMessage> {
+    const interception = await this.interceptor.intercept(request)
+
+    if (interception !== null)
+      return interception
+
     const match = this.tree.match(request.path)
 
     if (match === null)
@@ -68,6 +79,9 @@ export class Gateway extends Connector {
 
     const body = await request.parse()
 
+    if ('embed' in request && typeof body === 'object' && body !== null)
+      Object.assign(body, request.embed)
+
     const reply = await method.endpoint
       .call(body, request.query, parameters)
       .catch(rethrow) as Maybe<unknown>

package/source/HTTP/Server.fixtures.ts

@@ -1,4 +1,3 @@
-import { Buffer } from 'buffer'
 import { Readable } from 'stream'
 import type { IncomingMessage } from './messages'
 import type * as http from 'node:http'