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

package/source/directives/auth/Authorization.ts

@@ -56,7 +56,7 @@ export class Authorization implements Family<Directive, Extension> {
   public async preflight (directives: Directive[],
     input: Input,
     parameters: Parameter[]): Promise<Output> {
-    const identity = await this.resolve(input.headers.authorization)
+    const identity = await this.resolve(input.request.headers.authorization)
 
     input.identity = identity
 
@@ -67,8 +67,10 @@ export class Authorization implements Family<Directive, Extension> {
         return directive.reply?.(identity) ?? null
     }
 
-    if (identity === null) throw new http.Unauthorized()
-    else throw new http.Forbidden()
+    if (identity === null)
+      throw new http.Unauthorized()
+    else
+      throw new http.Forbidden()
   }
 
   public async settle (directives: Directive[],

package/source/directives/auth/Incept.ts

@@ -15,28 +15,33 @@ export class Incept implements Directive {
   }
 
   public authorize (identity: Identity | null, input: Input): boolean {
-    return identity === null && 'authorization' in input.headers
+    return identity === null && 'authorization' in input.request.headers
   }
 
-  public async settle (request: Input, response: http.OutgoingMessage): Promise<void> {
+  public async settle (input: Input, response: http.OutgoingMessage): Promise<void> {
     const id = response.body?.[this.property]
 
     if (id === undefined)
       throw new http.Conflict('Identity inception has failed as the response body ' +
         ` does not contain the '${this.property}' property.`)
 
-    const [scheme, credentials] = split(request.headers.authorization!)
+    const [scheme, credentials] = split(input.request.headers.authorization!)
     const provider = PROVIDERS[scheme]
 
     this.schemes[scheme] ??= await this.discovery[provider]
 
     const identity = await this.schemes[scheme]
-      .invoke<Maybe<Identity>>('create', { input: { id, credentials } })
+      .invoke<Maybe<Identity>>('create', {
+      input: {
+        id,
+        credentials
+      }
+    })
 
     if (identity instanceof Error)
       throw new http.Conflict(identity)
 
-    request.identity = identity
-    request.identity.scheme = scheme
+    input.identity = identity
+    input.identity.scheme = scheme
   }
 }

package/source/directives/auth/Role.ts

@@ -14,10 +14,12 @@ export class Role implements Directive {
   public static async set (identity: Identity, discovery: Promise<Component>): Promise<void> {
     this.remote ??= await discovery
 
-    const query: Query = { criteria: `identity==${identity.id}`, limit: 1024 }
-    const roles: string[] = await this.remote.invoke('list', { query })
+    const query: Query = {
+      criteria: `identity==${identity.id}`,
+      limit: 1024
+    }
 
-    identity.roles = roles
+    identity.roles = await this.remote.invoke('list', { query })
   }
 
   public async authorize (identity: Identity | null): Promise<boolean> {

package/source/directives/auth/Scheme.ts

@@ -12,10 +12,10 @@ export class Scheme implements Directive {
   }
 
   public authorize (_: Identity | null, input: Input): boolean {
-    if (input.headers.authorization === undefined)
+    if (input.request.headers.authorization === undefined)
       return false
 
-    const [scheme] = split(input.headers.authorization)
+    const [scheme] = split(input.request.headers.authorization)
 
     if (scheme !== this.scheme)
       throw new http.Forbidden(this.Scheme +

package/source/directives/cache/Cache.ts

@@ -23,9 +23,9 @@ export class Cache implements Family<Directive> {
   }
 
   public async settle
-  (directives: Directive[], request: Input, response: http.OutgoingMessage): Promise<void> {
+  (directives: Directive[], input: Input, response: http.OutgoingMessage): Promise<void> {
     response.headers ??= new Headers()
-    directives[0]?.set(request, response.headers)
+    directives[0]?.set(input, response.headers)
   }
 }
 

package/source/directives/cache/Control.ts

@@ -1,5 +1,5 @@
 import { match } from 'matchacho'
-import type { AuthenticatedRequest, Directive } from './types'
+import type { AuthenticatedContext, Directive } from './types'
 
 export class Control implements Directive {
   protected readonly value: string
@@ -9,16 +9,16 @@ export class Control implements Directive {
     this.value = value
   }
 
-  public set (request: AuthenticatedRequest, headers: Headers): void {
-    if (!['GET', 'HEAD', 'OPTIONS'].includes(request.method))
+  public set (context: AuthenticatedContext, headers: Headers): void {
+    if (!['GET', 'HEAD', 'OPTIONS'].includes(context.request.method))
       return
 
-    this.cache ??= this.resolve(request)
+    this.cache ??= this.resolve(context)
 
     headers.set('cache-control', this.cache)
   }
 
-  protected resolve (request: AuthenticatedRequest): string {
+  protected resolve (request: AuthenticatedContext): string {
     if (request.identity === null)
       return this.value
 

package/source/directives/cache/types.ts

@@ -4,6 +4,6 @@ export interface Directive {
   set: (input: Input, headers: Headers) => void
 }
 
-export interface AuthenticatedRequest extends Input {
+export interface AuthenticatedContext extends Input {
   identity?: unknown | null
 }

package/source/directives/cors/CORS.ts

@@ -17,12 +17,12 @@ export class CORS implements Interceptor {
   })
 
   public intercept (input: Input): Output {
-    const origin = input.headers.origin
+    const origin = input.request.headers.origin
 
     if (origin === undefined)
       return null
 
-    if (input.method === 'OPTIONS')
+    if (input.request.method === 'OPTIONS')
       return this.preflightResponse(origin)
 
     input.pipelines.response.push((output) => {
@@ -31,7 +31,9 @@ export class CORS implements Interceptor {
       output.headers.set('access-control-expose-headers',
         'authorization, content-type, content-length, etag')
 
-      if (input.method === 'GET' || input.method === 'HEAD' || input.method === 'OPTIONS')
+      const method = input.request.method
+
+      if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS')
         output.headers.append('vary', 'origin')
     })
 

package/source/directives/octets/Context.ts

@@ -6,7 +6,7 @@ export class Context implements Directive {
   public readonly targeted = false
   public readonly storage: string
 
-  public constructor (value: any) {
+  public constructor (value: unknown) {
     schemas.context.validate(value)
 
     this.storage = value

package/source/directives/octets/Delete.ts

@@ -1,9 +1,9 @@
 import { Readable } from 'stream'
 import { NotFound } from '../../HTTP'
 import * as schemas from './schemas'
-import { Workflow } from './workflow'
+import { Workflow } from './workflows'
 import type { Parameter } from '../../RTD'
-import type { Unit } from './workflow'
+import type { Unit } from './workflows'
 import type { Maybe } from '@toa.io/types'
 import type { Component } from '@toa.io/core'
 import type { Output } from '../../io'
@@ -27,11 +27,16 @@ export class Delete implements Directive {
     this.discovery = discovery
   }
 
-  public async apply (storage: string, request: Input, parameters: Parameter[]): Promise<Output> {
+  public async apply (storage: string, input: Input, parameters: Parameter[]): Promise<Output> {
     this.storage ??= await this.discovery
 
     const entry = await this.storage.invoke<Maybe<Entry>>('get',
-      { input: { storage, path: request.url } })
+      {
+        input: {
+          storage,
+          path: input.request.url
+        }
+      })
 
     if (entry instanceof Error)
       throw new NotFound()
@@ -40,31 +45,36 @@ export class Delete implements Directive {
 
     if (this.workflow !== undefined) {
       output.status = 202
-      output.body = Readable.from(this.execute(request, storage, entry, parameters))
+      output.body = Readable.from(this.execute(input, storage, entry, parameters))
     } else
-      await this.delete(storage, request)
+      await this.delete(storage, input)
 
     return output
   }
 
-  private async delete (storage: string, request: Input): Promise<void> {
+  private async delete (storage: string, input: Input): Promise<void> {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     await this.storage!.invoke('delete',
-      { input: { storage, path: request.url } })
+      {
+        input: {
+          storage,
+          path: input.request.url
+        }
+      })
   }
 
   // eslint-disable-next-line max-params
   private async * execute
-  (request: Input, storage: string, entry: Entry, parameters: Parameter[]): AsyncGenerator {
+  (input: Input, storage: string, entry: Entry, parameters: Parameter[]): AsyncGenerator {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    for await (const chunk of this.workflow!.execute(request, storage, entry, parameters)) {
+    for await (const chunk of this.workflow!.execute(input, storage, entry, parameters)) {
       yield chunk
 
       if (typeof chunk === 'object' && chunk !== null && 'error' in chunk)
         return
     }
 
-    await this.delete(storage, request)
+    await this.delete(storage, input)
   }
 }
 

package/source/directives/octets/Fetch.ts

@@ -12,7 +12,11 @@ import type { Directive, Input } from './types'
 export class Fetch implements Directive {
   public readonly targeted = true
 
-  private readonly permissions: Required<Permissions> = { blob: true, meta: false }
+  private readonly permissions: Required<Permissions> = {
+    blob: true,
+    meta: false
+  }
+
   private readonly discovery: Promise<Component>
   private storage: Component = null as unknown as Component
 
@@ -23,30 +27,34 @@ export class Fetch implements Directive {
     this.discovery = discovery
   }
 
-  public async apply (storage: string, request: Input): Promise<Output> {
+  public async apply (storage: string, input: Input): Promise<Output> {
     this.storage ??= await this.discovery
 
-    const variant = posix.basename(request.url).includes('.')
-    const metadata = request.subtype === 'octets.entry'
+    const variant = posix.basename(input.request.url).includes('.')
+    const metadata = input.subtype === 'octets.entry'
 
     if (!variant && metadata)
       if (this.permissions.meta)
-        return this.get(storage, request)
+        return this.get(storage, input)
       else
         throw new Forbidden('Metadata is not accessible.')
 
     if (!variant && !this.permissions.blob)
       throw new Forbidden('BLOB variant must be specified.')
 
-    return await this.fetch(storage, request)
+    return await this.fetch(storage, input)
   }
 
-  private async fetch (storage: string, request: Input): Promise<Output> {
-    if ('if-none-match' in request.headers)
+  private async fetch (storage: string, input: Input): Promise<Output> {
+    if ('if-none-match' in input.request.headers)
       return { status: 304 }
 
-    const input = { storage, path: request.url }
-    const result = await this.storage.invoke<Maybe<FetchResult>>('fetch', { input })
+    const result = await this.storage.invoke<Maybe<FetchResult>>('fetch', {
+      input: {
+        storage,
+        path: input.request.url
+      }
+    })
 
     if (result instanceof Error)
       throw new NotFound()
@@ -57,12 +65,19 @@ export class Fetch implements Directive {
       etag: result.checksum
     })
 
-    return { headers, body: result.stream }
+    return {
+      headers,
+      body: result.stream
+    }
   }
 
-  private async get (storage: string, request: Input): Promise<Output> {
-    const input = { storage, path: request.url }
-    const entry = await this.storage.invoke<Maybe<Entry>>('get', { input })
+  private async get (storage: string, input: Input): Promise<Output> {
+    const entry = await this.storage.invoke<Maybe<Entry>>('get', {
+      input: {
+        storage,
+        path: input.request.url
+      }
+    })
 
     if (entry instanceof Error)
       throw new NotFound()

package/source/directives/octets/List.ts

@@ -22,22 +22,26 @@ export class List implements Directive {
     this.discovery = discovery
   }
 
-  public async apply (storage: string, request: Input): Promise<Output> {
+  public async apply (storage: string, input: Input): Promise<Output> {
     this.storage ??= await this.discovery
 
-    const metadata = request.subtype === 'octets.entries'
+    const metadata = input.subtype === 'octets.entries'
 
     if (metadata && !this.permissions.meta)
       throw new Forbidden('Metadata is not accessible.')
 
-    const input = { storage, path: request.url }
-    const list = await this.storage.invoke<Maybe<string[]>>('list', { input })
+    const list = await this.storage.invoke<Maybe<string[]>>('list', {
+      input: {
+        storage,
+        path: input.request.url
+      }
+    })
 
     if (list instanceof Error)
       throw new NotFound()
 
     const body = metadata
-      ? await this.expand(storage, request.url, list)
+      ? await this.expand(storage, input.request.url, list)
       : list
 
     return { body }
@@ -47,7 +51,11 @@ export class List implements Directive {
   Promise<Array<Maybe<Entry>>> {
     const promises = list.map(async (id) => {
       const path = posix.join(prefix, id)
-      const input = { storage, path }
+
+      const input = {
+        storage,
+        path
+      }
 
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- ensured in `apply`
       return this.storage!.invoke<Maybe<Entry>>('get', { input })

package/source/directives/octets/Octets.ts

@@ -5,6 +5,7 @@ import { Fetch } from './Fetch'
 import { List } from './List'
 import { Delete } from './Delete'
 import { Permute } from './Permute'
+import { WorkflowDirective } from './Workflow'
 import type { Output } from '../../io'
 import type { Component } from '@toa.io/core'
 import type { Remotes } from '../../Remotes'
@@ -45,15 +46,17 @@ export class Octets implements Family<Directive> {
     if (action === null)
       return null
 
+    // noinspection PointlessBooleanExpressionJS
     if (context === null)
       throw new Error('Octets context is not defined.')
 
-    const targeted = input.path[input.path.length - 1] !== '/'
+    const targeted = input.request.url[input.request.url.length - 1] !== '/'
 
     if (targeted !== action.targeted)
       throw new NotFound(`Trailing slash is ${action.targeted ? 'redundant' : 'required'}.`)
 
-    return await action.apply(context.storage, input, parameters)
+    // noinspection JSObjectNullOrUndefined
+    return action.apply(context.storage, input, parameters)
   }
 }
 
@@ -63,7 +66,8 @@ const DIRECTIVES: Record<string, Constructor> = {
   fetch: Fetch,
   list: List,
   delete: Delete,
-  permute: Permute
+  permute: Permute,
+  workflow: WorkflowDirective
 }
 
 type Constructor = new (value: any, discovery: Promise<Component>, remotes: Remotes) => Directive

package/source/directives/octets/Permute.ts

@@ -18,16 +18,22 @@ export class Permute implements Directive {
     this.discovery = discovery
   }
 
-  public async apply (storage: string, request: Input): Promise<Output> {
+  public async apply (storage: string, input: Input): Promise<Output> {
     this.storage ??= await this.discovery
 
-    if (request.encoder === null)
+    if (input.encoder === null)
       throw new NotAcceptable()
 
-    const path = request.url
-    const list = await request.parse()
-    const input = { storage, path, list }
-    const error = await this.storage.invoke<Maybe<unknown>>('permute', { input })
+    const path = input.request.url
+    const list = await input.body()
+
+    const error = await this.storage.invoke<Maybe<unknown>>('permute', {
+      input: {
+        storage,
+        path,
+        list
+      }
+    })
 
     if (error instanceof Error)
       throw new NotFound()

package/source/directives/octets/Store.ts

@@ -1,10 +1,12 @@
+import { PassThrough } from 'node:stream'
 import { match } from 'matchacho'
 import { BadRequest, UnsupportedMediaType } from '../../HTTP'
 import { cors } from '../cors'
 import * as schemas from './schemas'
-import { Workflow } from './workflow'
+import { Workflow } from './workflows'
+import type { Readable } from 'stream'
 import type { Parameter } from '../../RTD'
-import type { Unit } from './workflow'
+import type { Unit } from './workflows'
 import type { Entry } from '@toa.io/extensions.storages'
 import type { Remotes } from '../../Remotes'
 import type { ErrorType } from 'error-value'
@@ -37,34 +39,46 @@ export class Store implements Directive {
     cors.allowHeader('content-meta')
   }
 
-  public async apply (storage: string, request: Input, parameters: Parameter[]): Promise<Output> {
+  public async apply (storage: string, input: Input, parameters: Parameter[]): Promise<Output> {
     this.storage ??= await this.discovery.storage
 
-    const input: StoreInput = { storage, request }
-    const meta = request.headers['content-meta']
+    const request: StoreRequest = { input: { storage, request: input.request } }
+    const meta = input.request.headers['content-meta']
 
     if (this.accept !== undefined)
-      input.accept = this.accept
+      request.input.accept = this.accept
 
     if (meta !== undefined)
-      input.meta = this.parseMeta(meta)
+      request.input.meta = this.parseMeta(meta)
 
-    const entry = await this.storage.invoke<Entry>('store', { input })
+    const entry = await this.storage.invoke<Entry>('store', request)
 
     return match<Output>(entry,
       Error, (error: ErrorType) => this.throw(error),
-      () => this.reply(request, storage, entry, parameters))
+      () => this.reply(input, storage, entry, parameters))
   }
 
   // eslint-disable-next-line max-params
-  private reply (request: Input, storage: string, entry: Entry, parameters: Parameter[]): Output {
+  private reply (input: Input, storage: string, entry: Entry, parameters: Parameter[]): Output {
     const body = this.workflow === undefined
       ? entry
-      : this.workflow.execute(request, storage, entry, parameters)
+      : this.execute(input, storage, entry, parameters)
 
     return { body }
   }
 
+  // eslint-disable-next-line max-params
+  private execute
+  (input: Input, storage: string, entry: Entry, parameters: Parameter[]): Readable {
+    const stream = new PassThrough({ objectMode: true })
+
+    stream.push(entry)
+
+    this.workflow!.execute(input, storage, entry, parameters).pipe(stream)
+
+    return stream
+  }
+
   private throw (error: ErrorType): never {
     throw match(error.code,
       'NOT_ACCEPTABLE', () => new UnsupportedMediaType(),
@@ -94,9 +108,11 @@ export interface Options {
   workflow?: Unit[] | Unit
 }
 
-interface StoreInput {
-  storage: string
-  request: Input
-  accept?: string
-  meta?: Record<string, string>
+interface StoreRequest {
+  input: {
+    storage: string
+    request: Input['request']
+    accept?: string
+    meta?: Record<string, string>
+  }
 }

package/source/directives/octets/Workflow.ts

@@ -0,0 +1,41 @@
+import { NotFound } from '../../HTTP'
+import * as schemas from './schemas'
+import { Workflow } from './workflows'
+import type { Unit } from './workflows'
+import type { Directive, Input } from './types'
+import type { Component } from '@toa.io/core'
+import type { Output } from '../../io'
+import type { Remotes } from '../../Remotes'
+import type { Maybe } from '@toa.io/types'
+import type { Entry } from '@toa.io/extensions.storages'
+import type { Parameter } from '../../RTD'
+
+export class WorkflowDirective implements Directive {
+  public readonly targeted = true
+
+  private readonly workflow: Workflow
+  private readonly discovery: Promise<Component>
+  private storage: Component | null = null
+
+  public constructor (units: Unit[] | Unit, discovery: Promise<Component>, remotes: Remotes) {
+    schemas.workflow.validate(units)
+
+    this.workflow = new Workflow(units, remotes)
+    this.discovery = discovery
+  }
+
+  public async apply (storage: string, input: Input, parameters: Parameter[]): Promise<Output> {
+    this.storage ??= await this.discovery
+
+    const entry = await this.storage.invoke<Maybe<Entry>>('get',
+      { input: { storage, path: input.request.url } })
+
+    if (entry instanceof Error)
+      throw new NotFound()
+
+    return {
+      status: 202,
+      body: this.workflow.execute(input, storage, entry, parameters)
+    }
+  }
+}

package/source/directives/octets/schemas.test.ts

@@ -0,0 +1,21 @@
+import * as schemas from './schemas'
+
+describe('workflow', () => {
+  const ok = [
+    { echo: 'hello world' },
+    [{ echo: 'hello world' }, { ok: 'ok' }]
+  ]
+
+  const oh = [
+    { echo: [] },
+    { echo: 'hello world', ok: { not: 'ok' } }
+  ]
+
+  it.each(ok)('should be valid', (workflow) => {
+    expect(() => schemas.workflow.validate(workflow)).not.toThrow()
+  })
+
+  it.each(oh)('should not be valid', (workflow) => {
+    expect(() => schemas.workflow.validate(workflow)).toThrow()
+  })
+})

package/source/directives/octets/schemas.ts

@@ -5,6 +5,7 @@ import type { Permissions as ListPermissions } from './List'
 import type { Options as StoreOptions } from './Store'
 import type { Options as DeleteOptions } from './Delete'
 import type { Schema } from '@toa.io/schemas'
+import type { Unit } from './workflows'
 
 const path = resolve(__dirname, '../../../schemas/octets')
 const namespace = schemas.namespace(path)
@@ -15,3 +16,4 @@ export const fetch: Schema<FetchPermissions | null> = namespace.schema('fetch')
 export const remove: Schema<DeleteOptions | null> = namespace.schema('delete')
 export const list: Schema<ListPermissions | null> = namespace.schema('list')
 export const permute: Schema<null> = namespace.schema('permute')
+export const workflow: Schema<Unit[] | Unit> = namespace.schema('workflow')

package/source/directives/octets/{workflow → workflows}/Execution.ts

@@ -27,8 +27,6 @@ export class Execution extends Readable {
   }
 
   private async run (): Promise<void> {
-    this.push(this.context.entry)
-
     for (const unit of this.units) {
       await this.execute(unit)
 

package/source/directives/octets/{workflow → workflows}/Workflow.ts

@@ -21,8 +21,8 @@ export class Workflow {
 
   // eslint-disable-next-line max-params
   public execute
-  (request: Input, storage: string, entry: Entry, params: Parameter[]): Execution {
-    const path = posix.join(request.path, entry.id)
+  (input: Input, storage: string, entry: Entry, params: Parameter[]): Execution {
+    const path = posix.join(input.request.url, entry.id)
     const parameters: Record<string, string> = {}
 
     for (const { name, value } of params)

package/source/directives/vary/Vary.ts

@@ -21,7 +21,7 @@ export class Vary implements Family {
 
   public preflight (instances: Array<Directive | Property>, request: Input): Output {
     /*
-    To stop consructing `properties` object on each request, Directive Families must be refactored
+    To stop constructing `properties` object on each request, Directive Families must be refactored
     from singleton factories to per-Node instances on the Tree.
      */
     const properties: Properties = {}

package/source/directives/vary/embeddings/Header.ts

@@ -12,7 +12,7 @@ export class Header implements Embedding {
   }
 
   public resolve (input: Input): string | undefined {
-    const value = input.headers[this.name]
+    const value = input.request.headers[this.name]
 
     if (value === undefined)
       return value