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

package/features/steps/Parameters.ts

@@ -1,4 +1,5 @@
 import { setDefaultTimeout } from '@cucumber/cucumber'
+import { encode } from '@toa.io/generic'
 
 export class Parameters {
   public readonly origin: string
@@ -9,7 +10,12 @@ export class Parameters {
 }
 
 setDefaultTimeout(30 * 1000)
+
 process.env.TOA_DEV = '1'
 
-// { octets: tmp:///exposition-octets }
-process.env.TOA_STORAGES = '3gABpm9jdGV0c7h0bXA6Ly8vZXhwb3NpdGlvbi1vY3RldHM='
+process.env.TOA_STORAGES = encode({
+  octets: {
+    provider: 'tmp',
+    directory: 'exposition'
+  }
+})

package/features/steps/Workspace.ts

@@ -1,17 +1,17 @@
 import { join } from 'node:path'
-import { tmpdir } from 'node:os'
-import { mkdtemp, copy } from 'fs-extra'
+import { tmpdir, devNull } from 'node:os'
+import { mkdtemp, cp } from 'node:fs/promises'
 import * as yaml from '@toa.io/yaml'
 
 export class Workspace {
-  private root: string = devnull
+  private root: string = devNull
 
   public static exists
   (_0: unknown, _1: unknown, descriptor: PropertyDescriptor): PropertyDescriptor {
     const method = descriptor.value
 
     descriptor.value = async function (this: Workspace, ...args: any[]): Promise<any> {
-      if (this.root === devnull) this.root =
+      if (this.root === devNull) this.root =
         await mkdtemp(join(tmpdir(), Math.random().toString(36).slice(2)))
 
       return method.apply(this, args)
@@ -25,7 +25,7 @@ export class Workspace {
     const source = join(__dirname, 'components', name)
     const target = join(this.root, name)
 
-    await copy(source, target)
+    await cp(source, target, { force: true, recursive: true })
 
     if (patch !== undefined)
       await this.patchManifest(target, patch)
@@ -39,5 +39,3 @@ export class Workspace {
     await yaml.patch(path, patch)
   }
 }
-
-const devnull = '/dev/null'

package/features/steps/components/echo/operations/error.js

@@ -0,0 +1,11 @@
+'use strict'
+
+function computation () {
+  const err = { code: 'CODE', message: 'message' }
+
+  Object.setPrototypeOf(err, Error.prototype)
+
+  return err
+}
+
+exports.computation = computation

package/features/steps/components/octets.tester/manifest.toa.yaml

@@ -9,7 +9,10 @@ operations:
       storage*: string
       path*: string
       entry: object
+      parameters: object
   bar: *operation
   baz: *operation
   err: *operation
+  echo: *operation
+  concat: *operation
   diversify: *operation

package/features/steps/components/octets.tester/operations/concat.js

@@ -0,0 +1,7 @@
+'use strict'
+
+function concat (input) {
+  return input.parameters.a + ' ' + input.parameters.b
+}
+
+exports.computation = concat

package/features/steps/components/octets.tester/operations/echo.js

@@ -0,0 +1,7 @@
+'use strict'
+
+function echo (input) {
+  return input.entry.id
+}
+
+exports.computation = echo

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

@@ -9,3 +9,6 @@ operations:
     concurrency: retry
     input:
       name*: ~
+  create:
+    query: false
+    forward: transit

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

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

package/features/steps/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "ESNext",
-    "outDir": "/dev/null",
+    "noEmit": true,
     "moduleResolution": "node",
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true

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": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.3",
   "description": "Toa Exposition",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -17,18 +17,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@toa.io/core": "1.0.0-alpha.0",
-    "@toa.io/generic": "1.0.0-alpha.0",
-    "@toa.io/http": "1.0.0-alpha.0",
-    "@toa.io/schemas": "1.0.0-alpha.0",
-    "@toa.io/streams": "1.0.0-alpha.0",
+    "@toa.io/core": "1.0.0-alpha.3",
+    "@toa.io/generic": "1.0.0-alpha.3",
+    "@toa.io/schemas": "1.0.0-alpha.3",
+    "@toa.io/streams": "1.0.0-alpha.3",
     "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"
   },
@@ -38,20 +36,21 @@
   },
   "scripts": {
     "test": "jest",
-    "transpile": "rm -rf transpiled && npx tsc && npm run transpile:basic && npm run transpile:tokens && npm run transpile:roles",
-    "transpile:basic": "rm -rf ./components/identity.basic/operations && npx tsc -p ./components/identity.basic",
-    "transpile:tokens": "rm -rf ./components/identity.tokens/operations && npx tsc -p ./components/identity.tokens",
-    "transpile:roles": "rm -rf ./components/identity.roles/operations && 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": "1.0.0-alpha.0",
+    "@toa.io/agent": "1.0.0-alpha.3",
+    "@toa.io/extensions.storages": "1.0.0-alpha.3",
     "@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": "06c64546f6292cc07c52f74b31415101037f7616"
+  "gitHead": "e36ac7871fc14d15863aaf8f9bbdeace8bdfa9f0"
 }

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/schemas/octets/workflow.cos.yaml

@@ -0,0 +1,12 @@
+definitions:
+  unit:
+    type: object
+    patternProperties:
+      ^[a-zA-Z0-9_]+$:
+        type: string
+
+oneOf:
+  - $ref: '#/definitions/unit'
+  - type: array
+    items:
+      $ref: '#/definitions/unit'

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'