@toa.io/extensions.exposition 1.0.0-alpha.28 → 1.0.0-alpha.283

package/features/steps/OTP.ts

@@ -0,0 +1,42 @@
+import * as assert from 'node:assert'
+import tsflow from 'cucumber-tsflow'
+
+import * as boot from '@toa.io/boot'
+import { Locator, type Remote } from '@toa.io/core'
+import { Captures } from './Captures.js'
+
+const { binding, given } = tsflow
+
+@binding([Captures])
+export class OTP {
+  private captures: Captures
+  private otp: Remote | null = null
+
+  public constructor (captures: Captures) {
+    this.captures = captures
+  }
+
+  @given('OTP for `{word}` in `{word}` authority is issued')
+  public async issue (username: string, authority: string): Promise<void> {
+    this.otp ??= await this.connect()
+
+    const reply = await this.otp.invoke('issue', {
+      input: {
+        username,
+        authority
+      }
+    })
+
+    assert.ok(typeof reply.code === 'string')
+
+    const credentials = btoa(`${username}:${reply.code}`)
+
+    this.captures.set(`${username}.otp`, credentials)
+  }
+
+  private async connect (): Promise<Remote> {
+    const locator = new Locator('otp', 'identity')
+
+    return await boot.remote(locator)
+  }
+}

package/features/steps/Parameters.ts

@@ -1,5 +1,8 @@
+import { join } from 'node:path'
+import * as dotenv from 'dotenv'
 import { setDefaultTimeout } from '@cucumber/cucumber'
-import { encode } from '@toa.io/generic'
+
+dotenv.config({ path: join(import.meta.dirname, '.env') })
 
 export class Parameters {
   public readonly origin: string
@@ -9,13 +12,109 @@ export class Parameters {
   }
 }
 
-setDefaultTimeout(30 * 1000)
+setDefaultTimeout(60 * 1000)
 
 process.env.TOA_DEV = '1'
 
-process.env.TOA_STORAGES = encode({
+// a reply is checked against what the operation declares, so the suite runs Toa under the
+// contract it asks applications to keep
+process.env.TOA_ENV ??= 'local'
+
+// the gateway answers for itself, as it does in a deployment: telemetry's probe tracks the
+// nested composition, which connects before route discovery settles
+process.env.TOA_TELEMETRY_READY ??= JSON.stringify(false)
+
+// export traces to the local Tempo (`docker compose up tempo grafana`),
+// unavailability of the endpoint is harmless
+process.env.TOA_TELEMETRY_TRACES ??= JSON.stringify({
+  exporters: {
+    console: null,
+    otlp: { endpoint: 'http://localhost:4318' }
+  }
+})
+
+process.env.TOA_STORAGES = JSON.stringify({
   octets: {
     provider: 'tmp',
-    directory: 'exposition'
+    directory: Math.random().toString(36).substring(2)
+  },
+  cloudinary: {
+    provider: 'cloudinary',
+    environment: process.env.CLOUDINARY_ENVIRONMENT ?? 'nope',
+    type: 'image',
+    prefix: 'toa-dev',
+    transformations: [
+      {
+        extension: 'icon',
+        transformation: [{
+          width: 48,
+          height: 48,
+          crop: 'fill'
+        }, {
+          border: '10px_solid_white'
+        }],
+        optional: true
+      },
+      {
+        extension: '(?<width>\\d*)x(?<height>\\d*)(z(?<zoom>\\d*))?',
+        transformation: {
+          width: '<width>',
+          height: '<height>',
+          zoom: '<zoom>',
+          crop: 'thumb',
+          gravity: 'face'
+        },
+        optional: true
+      },
+      {
+        extension: '\\[(?<width>\\d*)x(?<height>\\d*)\\](z(?<zoom>\\d+))?',
+        transformation: {
+          width: '<width>',
+          height: '<height>',
+          zoom: '<zoom>',
+          crop: 'fit'
+        },
+        optional: true
+      },
+      {
+        extension: '(?<format>jpeg|webp)',
+        transformation: {
+          fetch_format: '<format>'
+        },
+        optional: true
+      }
+    ]
+  },
+  cloudinary_video: {
+    provider: 'cloudinary',
+    environment: process.env.CLOUDINARY_ENVIRONMENT ?? 'nope',
+    type: 'video',
+    prefix: 'toa-dev',
+    eager: [
+      {
+        width: 200,
+        height: 200,
+        crop: 'fill'
+      }
+    ],
+    transformations: [
+      {
+        extension: '200x200',
+        transformation: {
+          width: 200,
+          height: 200,
+          crop: 'fill'
+        },
+        optional: true
+      },
+      {
+        extension: '(?<format>mp4|gif)',
+        transformation: {
+          quality: 'auto',
+          fetch_format: '<format>'
+        },
+        optional: true
+      }
+    ]
   }
 })

package/features/steps/Probe.ts

@@ -0,0 +1,36 @@
+import assert from 'node:assert'
+import { Agent, request } from 'undici'
+import tsflow from 'cucumber-tsflow'
+import { PATH, PROBE } from '../../source/HTTP/index.js'
+
+const { after, binding, then, when } = tsflow
+
+@binding()
+export class Probe {
+  private readonly agent = new Agent()
+  private status: number | null = null
+  private headers: Record<string, string> = {}
+
+  @when('the ready probe is requested')
+  public async request (): Promise<void> {
+    const response = await request(`http://127.0.0.1:${PROBE}${PATH}`, { dispatcher: this.agent })
+
+    this.status = response.statusCode
+    this.headers = response.headers as Record<string, string>
+
+    await response.body.dump()
+  }
+
+  @then('the ready probe answers {int}')
+  public answers (status: number): void {
+    assert.equal(this.status, status)
+
+    if (status === 200)
+      assert.equal(this.headers['cache-control'], 'no-store')
+  }
+
+  @after()
+  public async close (): Promise<void> {
+    await this.agent.close()
+  }
+}

package/features/steps/Realtime.ts

@@ -0,0 +1,154 @@
+import { EventEmitter, once } from 'node:events'
+import * as assert from 'node:assert'
+import tsflow from 'cucumber-tsflow'
+
+import { Factory } from '@toa.io/extensions.realtime'
+import * as boot from '@toa.io/boot'
+import { match } from '@toa.io/generic'
+import { load as parse } from 'js-yaml'
+import { Agent } from '@toa.io/agent'
+import { Parameters } from './Parameters.js'
+import { Gateway } from './Gateway.js'
+import { Captures } from './Captures.js'
+import type { Connector } from '@toa.io/core'
+
+const { after, binding, given, afterAll, then } = tsflow
+
+@binding([Gateway, Parameters, Captures])
+export class Realtime {
+  private static instance: Connector | null = null
+  private readonly gateway: Gateway
+  private readonly agent: Agent
+  private readonly events = new EventEmitter()
+  private log: Record<string, unknown[]> = {}
+  private aborted = false
+
+  public constructor (gateway: Gateway, parameters: Parameters, captures: Captures) {
+    this.gateway = gateway
+    this.agent = new Agent(parameters.origin, captures)
+  }
+
+  @given('the Realtime is running with the following annotation:')
+  public async start (yaml: string): Promise<void> {
+    await Realtime.stop()
+
+    const annotation = parse(yaml) as Record<string, string>
+    const routes = []
+
+    for (const [event, property] of Object.entries(annotation))
+      routes.push({ event, properties: [property] })
+
+    process.env.TOA_REALTIME = JSON.stringify(routes)
+
+    const factory = new Factory(boot.host())
+
+    Realtime.instance = await factory.service()
+
+    void Realtime.instance.connect()
+  }
+
+  @given('the identity {word} is consuming realtime events')
+  public async connect (name: string): Promise<void> {
+    await this.gateway.start()
+
+    const id = await this.createIdentity(name)
+
+    const parts = await this.agent.parts(`
+      GET /realtime/streams/\${{ ${name}.id }}/ HTTP/1.1
+      authorization: Token \${{ ${name}.token }}
+      accept: application/json
+    `) as AsyncIterable<Uint8Array>
+
+    void this.consume(id, parts).catch((e) => {
+      if (!this.aborted)
+        console.debug('Consumption interrupted', e)
+    })
+  }
+
+  @then('the following event `{word}` is received by {word}:')
+  public async received (label: string, name: string, yaml: string): Promise<void> {
+    const id = this.agent.captures.get(`${name}.id`)
+    const tag = `${id}:${label}`
+    const expected = parse(yaml)
+
+    if (this.log[tag] !== undefined)
+      for (const data of this.log[tag])
+        // eslint-disable-next-line max-depth
+        if (match(data, expected))
+          return
+
+    const [event] = await once(this.events, tag)
+
+    assert.ok(match(event, expected), 'Event does not match')
+  }
+
+  @after()
+  public abort (): void {
+    this.aborted = true
+    this.agent.abort()
+    this.log = {}
+    this.events.removeAllListeners()
+  }
+
+  @afterAll()
+  public static async stop (): Promise<void> {
+    if (this.instance === null)
+      return
+
+    await this.instance.disconnect()
+
+    this.instance = null
+    process.env.TOA_REALTIME = undefined
+  }
+
+  private async createIdentity (name: string): Promise<string> {
+    const password = Math.random().toString(36).slice(2)
+    const username = name + Math.random().toString(36).slice(2)
+
+    await this.agent.request(`
+      POST /identity/basic/ HTTP/1.1
+      accept: application/yaml
+      content-type: application/yaml
+
+      username: ${username}
+      password: ${password}
+    `)
+
+    this.agent.responseIncludes(`
+      201 Created
+    `)
+
+    const credentials = Buffer.from(`${username}:${password}`).toString('base64')
+
+    await this.agent.request(`
+      GET /identity/ HTTP/1.1
+      authorization: Basic ${credentials}
+      accept: application/yaml
+    `)
+
+    this.agent.responseIncludes(`
+      200 OK
+      authorization: Token \${{ ${name}.token }}
+
+      id: \${{ ${name}.id }}
+    `)
+
+    return this.agent.captures.get(`${name}.id`) as string
+  }
+
+  private async consume (id: string, parts: any): Promise<void> {
+    for await (const part of parts) {
+      const text = Buffer.from(part.body).toString('utf8')
+      const event = JSON.parse(text)
+
+      if (typeof event === 'string')
+        continue
+
+      const tag = `${id}:${event.event}`
+
+      this.events.emit(tag, event.data)
+      this.log[tag] ??= []
+      this.log[tag].push(event.data)
+    }
+  }
+}

package/features/steps/Workspace.ts

@@ -1,13 +1,13 @@
 import { join } from 'node:path'
 import { tmpdir, devNull } from 'node:os'
-import { mkdtemp, cp } from 'node:fs/promises'
-import * as yaml from '@toa.io/yaml'
+import { mkdtemp, cp, readFile, writeFile } from 'node:fs/promises'
+import { load, dump } from 'js-yaml'
+import { overwrite } from '@toa.io/generic'
 
 export class Workspace {
   private root: string = devNull
 
-  public static exists
-  (_0: unknown, _1: unknown, descriptor: PropertyDescriptor): PropertyDescriptor {
+  public static exists (_0: unknown, _1: unknown, descriptor: PropertyDescriptor): PropertyDescriptor {
     const method = descriptor.value
 
     descriptor.value = async function (this: Workspace, ...args: any[]): Promise<any> {
@@ -22,7 +22,7 @@ export class Workspace {
 
   @Workspace.exists
   public async addComponent (name: string, patch?: object): Promise<string> {
-    const source = join(__dirname, 'components', name)
+    const source = join(import.meta.dirname, 'components', name)
     const target = join(this.root, name)
 
     await cp(source, target, { force: true, recursive: true })
@@ -36,6 +36,10 @@ export class Workspace {
   private async patchManifest (target: string, patch: object): Promise<void> {
     const path = join(target, 'manifest.toa.yaml')
 
-    await yaml.patch(path, patch)
+    const manifest = load(await readFile(path, 'utf8')) as object
+
+    overwrite(manifest, patch)
+
+    await writeFile(path, dump(manifest, { noRefs: true, lineWidth: -1 }), 'utf8')
   }
 }

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

@@ -0,0 +1,20 @@
+name: audit
+
+operations:
+  record:
+    input:
+      properties:
+        id:
+          type: string
+        title:
+          type: string
+        volume:
+          type: number
+        price:
+          type: number
+      type: object
+    output:
+      {}
+
+receivers:
+  orders.created: record

package/features/steps/components/audit/operations/record.js

@@ -0,0 +1,5 @@
+export async function effect (input) {
+  await new Promise((resolve) => setTimeout(resolve, 500))
+
+  return null
+}

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

@@ -3,12 +3,56 @@ name: echo
 operations:
   compute:
     input:
-      name*: string
+      properties:
+        name:
+          type: string
+      type: object
+      required:
+        - name
   affect:
     input:
-      name*: string
+      properties:
+        name:
+          type: string
+      type: object
+      required:
+        - name
   identity:
     input:
-      identity:
-        id: string
-        roles: [string]
+      properties:
+        identity:
+          properties:
+            id:
+              type: string
+            roles:
+              type: array
+              items:
+                type: string
+          type: object
+      type: object
+  parameters:
+    input:
+      type: object
+      properties:
+        a:
+          type: string
+        b:
+          type: string
+    output:
+      type: object
+      properties:
+        a:
+          type: string
+        b:
+          type: string
+  echo:
+    input:
+      type: object
+  unwrap:
+    input:
+      type: object
+      properties:
+        buf:
+          type: string
+  error:
+    errors: [CODE]

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

@@ -1,7 +1,3 @@
-'use strict'
-
-function effect (input) {
+export function effect (input) {
   return `Hello ${input.name}`
 }
-
-exports.effect = effect

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

@@ -1,7 +1,3 @@
-'use strict'
-
-function computation (input) {
+export function computation (input) {
   return `Hello ${input.name}`
 }
-
-exports.computation = computation

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

@@ -0,0 +1,3 @@
+export function computation (input) {
+  return input
+}

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

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

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

@@ -1,7 +1,3 @@
-'use strict'
-
-function computation (input) {
+export function computation (input) {
   return input
 }
-
-exports.computation = computation

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

@@ -0,0 +1,3 @@
+export function computation (input) {
+  return input
+}

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

@@ -0,0 +1,3 @@
+export function computation () {
+  return 'pong'
+}

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

@@ -0,0 +1,3 @@
+export function computation (input) {
+  return JSON.parse(input.buf)
+}

package/features/steps/components/echo.beacon/manifest.toa.yaml

@@ -0,0 +1,2 @@
+namespace: echo
+name: beacon

package/features/steps/components/echo.beacon/operations/hello.js

@@ -0,0 +1,3 @@
+export const computation = () => {
+  return 'Hello!'
+}

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

@@ -1,5 +1,4 @@
 name: greeter
-version: 0.0.0
 
 exposition:
   /:

package/features/steps/components/greeter/operations/greet.js

@@ -1,7 +1,3 @@
-'use strict'
-
-function computation () {
+export function computation () {
   return 'Hello'
 }
-
-exports.computation = computation

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

@@ -0,0 +1,20 @@
+name: notify
+
+operations:
+  send:
+    input:
+      properties:
+        id:
+          type: string
+        title:
+          type: string
+        volume:
+          type: number
+        price:
+          type: number
+      type: object
+    output:
+      {}
+
+receivers:
+  orders.created: send

package/features/steps/components/notify/operations/send.js

@@ -0,0 +1,5 @@
+export async function effect (input) {
+  await new Promise((resolve) => setTimeout(resolve, 800))
+
+  return null
+}

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

@@ -1,19 +1,73 @@
 namespace: octets
 name: tester
-version: 0.0.0
 
 storages: octets
 
 operations:
   foo: &operation
+    errors: [ERROR, NOT_FOUND]
     input:
-      storage*: string
-      path*: string
-      entry: object
-      parameters: object
+      properties:
+        identity:
+          type: string
+        parameters:
+          type: object
+        steps:
+          type: object
+        authority:
+          type: string
+        storage:
+          type: string
+        path:
+          type: string
+        entry:
+          type: object
+      type: object
+      required:
+        - authority
+        - storage
+        - path
+        - entry
   bar: *operation
   baz: *operation
   err: *operation
+  id: *operation
   echo: *operation
   concat: *operation
-  diversify: *operation
+  yield: *operation
+  yex: *operation
+  authority: *operation
+  identity: *operation
+  redirect:
+    errors: [ERROR]
+    input:
+      properties:
+        parameters:
+          type: object
+          patternProperties:
+            ^.+$:
+              type: string
+        authority:
+          type: string
+        path:
+          type: string
+      type: object
+      required:
+        - authority
+        - path
+    output:
+      type: object
+      properties:
+        url:
+          type: string
+        options:
+          type: object
+          properties:
+            method:
+              type: string
+            headers:
+              type: object
+            body:
+              type: string
+      required:
+        - url

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

@@ -0,0 +1,3 @@
+export function computation (input) {
+  return input.authority
+}