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

package/source/directives/io/Input.ts

@@ -0,0 +1,50 @@
+import { BadRequest } from '../../HTTP'
+import * as schemas from './schemas'
+import type { Message } from './Message'
+import type { Directive } from './Directive'
+import type { Input as Context } from '../../io'
+
+export class Input implements Directive {
+  private readonly permissions: Permissions
+
+  public constructor (permissions: Permissions) {
+    this.permissions = permissions
+  }
+
+  public static validate (permissions: unknown): asserts permissions is Permissions {
+    schemas.input.validate(permissions, 'Incorrect \'io:input\' format')
+  }
+
+  public attach (context: Context): void {
+    context.pipelines.body.push((body) => this.check(body))
+  }
+
+  private check (body: unknown): unknown {
+    try {
+      schemas.message.validate(body)
+    } catch {
+      throw new BadRequest('Invalid request body.')
+    }
+
+    const property = this.violation(body)
+
+    if (property !== undefined)
+      throw new BadRequest(`Unexpected input: ${property}.`)
+
+    return body
+  }
+
+  private violation (value: Message | Message[]): string | undefined {
+    if (!Array.isArray(value))
+      return Object.keys(value).find((key) => !this.permissions.includes(key))
+
+    for (const item of value) {
+      const property = this.violation(item)
+
+      if (property !== undefined)
+        return property
+    }
+  }
+}
+
+export type Permissions = string[]

package/source/directives/io/Message.ts

@@ -0,0 +1 @@
+export type Message = Record<string, unknown>

package/source/directives/io/Output.ts

@@ -0,0 +1,69 @@
+import { Stream } from 'node:stream'
+import * as schemas from './schemas'
+import type { Message } from './Message'
+import type { Directive } from './Directive'
+import type { Input as Context } from '../../io'
+import type { OutgoingMessage } from '../../HTTP'
+
+export class Output implements Directive {
+  private readonly disabled: boolean = false
+  private readonly omitted: boolean = true
+  private readonly permissions: string[] = []
+
+  public constructor (permissions: Permissions) {
+    if (typeof permissions === 'boolean')
+      if (permissions)
+        this.disabled = true
+      else
+        this.omitted = false
+
+    else
+      this.permissions = permissions
+  }
+
+  public static validate (permissions: unknown): asserts permissions is Permissions {
+    schemas.output.validate(permissions, 'Incorrect \'io:output\' format')
+  }
+
+  public attach (context: Context): void {
+    context.pipelines.response.push(this.restriction(context))
+  }
+
+  private restriction (context: Context) {
+    return (message: OutgoingMessage): void => {
+      const error = message.status !== undefined && message.status >= 300
+      const stream = message.body instanceof Stream
+      const none = message.body === undefined || message.body === null
+
+      if (this.disabled || error || stream || none)
+        return
+
+      if (typeof message.body !== 'object' || this.permissions.length === 0) {
+        if (this.omitted)
+          console.warn('Permissions for \'io:output\' are not specified properly ' +
+            `(${context.request.url}). Response omitted.`)
+
+        delete message.body
+
+        return
+      }
+
+      schemas.message.validate(message.body,
+        '\'io:output\' expects response to be an object or array of objects')
+
+      if (Array.isArray(message.body))
+        message.body = message.body.map((entity) => this.fit(entity))
+      else
+        message.body = this.fit(message.body)
+    }
+  }
+
+  private fit (message: Message): Message | undefined {
+    const entries = Object.entries(message)
+      .filter(([key]) => this.permissions.includes(key))
+
+    return Object.fromEntries(entries)
+  }
+}
+
+export type Permissions = string[] | boolean

package/source/directives/io/index.ts

@@ -0,0 +1,3 @@
+import { IO } from './IO'
+
+export const io = new IO()

package/source/directives/io/schemas.ts

@@ -0,0 +1,12 @@
+import { resolve } from 'node:path'
+import schemas, { type Schema } from '@toa.io/schemas'
+import type { Permissions as InputPermissions } from './Input'
+import type { Permissions as OutputPermissions } from './Output'
+import type { Message } from './Message'
+
+const path = resolve(__dirname, '../../../schemas/io')
+const namespace = schemas.namespace(path)
+
+export const message: Schema<Message | Message[]> = namespace.schema('message')
+export const input: Schema<InputPermissions> = namespace.schema('input')
+export const output: Schema<OutputPermissions> = namespace.schema('output')

package/source/directives/octets/Context.ts

@@ -1,18 +1,19 @@
 import * as schemas from './schemas'
-import type { Output } from '../../Directive'
-import type { Directive } from './types'
+import { Directive } from './Directive'
+import type { Output } from '../../io'
 
-export class Context implements Directive {
+export class Context extends Directive {
   public readonly targeted = false
   public readonly storage: string
 
-  public constructor (value: any) {
+  public constructor (value: unknown) {
+    super()
     schemas.context.validate(value)
 
     this.storage = value
   }
 
-  public apply (): Output {
+  public async apply (): Promise<Output> {
     return null
   }
 }

package/source/directives/octets/Delete.ts

@@ -1,32 +1,85 @@
+import { Readable } from 'stream'
 import { NotFound } from '../../HTTP'
 import * as schemas from './schemas'
+import { Workflow } from './workflows'
+import { Directive } from './Directive'
+import type { Parameter } from '../../RTD'
+import type { Unit } from './workflows'
 import type { Maybe } from '@toa.io/types'
 import type { Component } from '@toa.io/core'
-import type { Output } from '../../Directive'
+import type { Output } from '../../io'
+import type { Input } from './types'
+import type { Remotes } from '../../Remotes'
+import type { Entry } from '@toa.io/extensions.storages'
 
-import type { Directive, Input } from './types'
-
-export class Delete implements Directive {
+export class Delete extends Directive {
   public readonly targeted = true
 
+  private readonly workflow?: Workflow
   private readonly discovery: Promise<Component>
   private storage: Component | null = null
 
-  public constructor (value: null, discovery: Promise<Component>) {
-    schemas.remove.validate(value)
+  public constructor (options: Options | null, discovery: Promise<Component>, remotes: Remotes) {
+    super()
+    schemas.remove.validate(options)
+
+    if (options?.workflow !== undefined)
+      this.workflow = new Workflow(options.workflow, remotes)
 
     this.discovery = discovery
   }
 
-  public async apply (storage: string, request: Input): Promise<Output> {
+  public async apply (storage: string, input: Input, parameters: Parameter[]): Promise<Output> {
     this.storage ??= await this.discovery
 
-    const input = { storage, path: request.path }
-    const error = await this.storage.invoke<Maybe<unknown>>('delete', { input })
+    const entry = await this.storage.invoke<Maybe<Entry>>('get',
+      {
+        input: {
+          storage,
+          path: input.request.url
+        }
+      })
 
-    if (error instanceof Error)
+    if (entry instanceof Error)
       throw new NotFound()
 
-    return {}
+    const output: Output = {}
+
+    if (this.workflow !== undefined) {
+      output.status = 202
+      output.body = Readable.from(this.execute(input, storage, entry, parameters))
+    } else
+      await this.delete(storage, input)
+
+    return output
+  }
+
+  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: input.request.url
+        }
+      })
   }
+
+  // eslint-disable-next-line max-params
+  private async * execute
+  (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(input, storage, entry, parameters)) {
+      yield chunk
+
+      if (typeof chunk === 'object' && chunk !== null && 'error' in chunk)
+        return
+    }
+
+    await this.delete(storage, input)
+  }
+}
+
+export interface Options {
+  workflow?: Unit[] | Unit
 }

package/source/directives/octets/Directive.ts

@@ -0,0 +1,10 @@
+import type { Input } from './types'
+import type { Parameter } from '../../RTD'
+import type * as io from '../../io'
+
+export abstract class Directive {
+  public readonly name = 'octets.' + this.constructor.name.toLowerCase()
+  public abstract readonly targeted: boolean
+
+  public abstract apply (storage: string, input: Input, parameters: Parameter[]): Promise<io.Output>
+}

package/source/directives/octets/Fetch.ts

@@ -1,49 +1,61 @@
 import { posix } from 'node:path'
 import { Forbidden, NotFound } from '../../HTTP'
 import * as schemas from './schemas'
+import { Directive } from './Directive'
 import type { Maybe } from '@toa.io/types'
 import type { Entry } from '@toa.io/extensions.storages'
 import type { Readable } from 'node:stream'
 import type { Component } from '@toa.io/core'
-import type { Output } from '../../Directive'
+import type { Output } from '../../io'
+import type { Input } from './types'
 
-import type { Directive, Input } from './types'
-
-export class Fetch implements Directive {
+export class Fetch extends Directive {
   public readonly targeted = true
 
-  private readonly permissions: 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
 
-  public constructor (permissions: Partial<Permissions> | null, discovery: Promise<Component>) {
+  public constructor (permissions: Permissions | null, discovery: Promise<Component>) {
+    super()
     schemas.fetch.validate(permissions)
 
     Object.assign(this.permissions, permissions)
     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.url.slice(-5) === ':meta')
-      return await this.get(storage, request)
-    else
-      return await this.fetch(storage, request)
-  }
+    const variant = posix.basename(input.request.url).includes('.')
+    const metadata = input.subtype === 'octets.entry'
 
-  private async fetch (storage: string, request: Input): Promise<Output> {
-    const filename = posix.basename(request.url)
-    const variant = filename.includes('.')
+    if (!variant && metadata)
+      if (this.permissions.meta)
+        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.')
 
-    if ('if-none-match' in request.headers)
+    return await this.fetch(storage, input)
+  }
+
+  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()
@@ -54,16 +66,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> {
-    if (!this.permissions.meta)
-      throw new Forbidden('Metadata is not accessible.')
-
-    const path = request.url.slice(0, -5)
-    const input = { storage, path }
-    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()
@@ -72,9 +87,9 @@ export class Fetch implements Directive {
   }
 }
 
-interface Permissions {
-  blob: boolean
-  meta: boolean
+export interface Permissions {
+  blob?: boolean
+  meta?: boolean
 }
 
 interface FetchResult {

package/source/directives/octets/List.ts

@@ -1,32 +1,72 @@
-import { NotFound } from '../../HTTP'
+import { posix } from 'node:path'
+import { Forbidden, NotFound } from '../../HTTP'
 import * as schemas from './schemas'
+import { Directive } from './Directive'
+import type { Entry } from '@toa.io/extensions.storages'
 import type { Maybe } from '@toa.io/types'
 import type { Component } from '@toa.io/core'
-import type { Output } from '../../Directive'
+import type { Output } from '../../io'
 
-import type { Directive, Input } from './types'
+import type { Input } from './types'
 
-export class List implements Directive {
+export class List extends Directive {
   public readonly targeted = false
 
+  private readonly permissions: Required<Permissions> = { meta: false }
   private readonly discovery: Promise<Component>
   private storage: Component | null = null
 
-  public constructor (value: null, discovery: Promise<Component>) {
-    schemas.remove.validate(value)
+  public constructor (permissions: Permissions | null, discovery: Promise<Component>) {
+    super()
+    schemas.list.validate(permissions)
 
+    Object.assign(this.permissions, permissions)
     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 input = { storage, path: request.path }
-    const list = await this.storage.invoke<Maybe<unknown>>('list', { input })
+    const metadata = input.subtype === 'octets.entries'
+
+    if (metadata && !this.permissions.meta)
+      throw new Forbidden('Metadata is not accessible.')
+
+    const list = await this.storage.invoke<Maybe<string[]>>('list', {
+      input: {
+        storage,
+        path: input.request.url
+      }
+    })
 
     if (list instanceof Error)
       throw new NotFound()
 
-    return { body: list }
+    const body = metadata
+      ? await this.expand(storage, input.request.url, list)
+      : list
+
+    return { body }
+  }
+
+  private async expand (storage: string, prefix: string, list: string[]):
+  Promise<Array<Maybe<Entry>>> {
+    const promises = list.map(async (id) => {
+      const path = posix.join(prefix, id)
+
+      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 })
+    })
+
+    return await Promise.all(promises)
   }
 }
+
+export interface Permissions {
+  meta?: boolean
+}

package/source/directives/octets/{Family.ts → Octets.ts}

@@ -5,12 +5,15 @@ import { Fetch } from './Fetch'
 import { List } from './List'
 import { Delete } from './Delete'
 import { Permute } from './Permute'
+import { WorkflowDirective } from './Workflow'
+import type { Directive } from './Directive'
+import type { Output } from '../../io'
 import type { Component } from '@toa.io/core'
 import type { Remotes } from '../../Remotes'
-import type { Output, Family } from '../../Directive'
-import type { Directive, Input } from './types'
+import type { Parameter, DirectiveFamily } from '../../RTD'
+import type { Input } from './types'
 
-class Octets implements Family<Directive> {
+export class Octets implements DirectiveFamily<Directive> {
   public readonly name: string = 'octets'
   public readonly mandatory: boolean = false
 
@@ -27,7 +30,8 @@ class Octets implements Family<Directive> {
     return new Class(value, this.discovery, remotes)
   }
 
-  public async preflight (directives: Directive[], input: Input): Promise<Output> {
+  public async preflight
+  (directives: Directive[], input: Input, parameters: Parameter[]): Promise<Output> {
     let context: Context | null = null
     let action: Directive | null = null
 
@@ -42,15 +46,17 @@ 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)
+    // noinspection JSObjectNullOrUndefined
+    return await input.timing.capture(action.name, action.apply(context.storage, input, parameters))
   }
 }
 
@@ -60,9 +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
-
-export = new Octets()

package/source/directives/octets/Permute.ts

@@ -1,33 +1,40 @@
 import { NotAcceptable, NotFound } from '../../HTTP'
 import * as schemas from './schemas'
+import { Directive } from './Directive'
 import type { Maybe } from '@toa.io/types'
 import type { Component } from '@toa.io/core'
-import type { Output } from '../../Directive'
+import type { Output } from '../../io'
+import type { Input } from './types'
 
-import type { Directive, Input } from './types'
-
-export class Permute implements Directive {
+export class Permute extends Directive {
   public readonly targeted = false
 
   private readonly discovery: Promise<Component>
   private storage: Component | null = null
 
   public constructor (value: null, discovery: Promise<Component>) {
-    schemas.remove.validate(value)
+    super()
+    schemas.permute.validate(value)
 
     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.path
-    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()