@toa.io/extensions.exposition 1.0.0-alpha.284 → 1.0.0-alpha.286

package/source/directives/octets/Get.ts

@@ -1,7 +1,7 @@
 import { Forbidden, NotFound } from '../../HTTP/index.js'
 import * as schemas from './schemas.js'
 import { Directive } from './Directive.js'
-import type { Maybe } from '@toa.io/core'
+import type { Maybe } from '@toa.io/core/types'
 import type { Entry, Stream } from '@toa.io/extensions.storages'
 import type { Component } from '@toa.io/core'
 import type { Output } from '../../io.js'
@@ -17,7 +17,7 @@ export class Get extends Directive {
   private readonly discovery: Promise<Component>
   private storage!: Component
 
-  public constructor (options: Options | null, discovery: Promise<Component>) {
+  public constructor(options: Options | null, discovery: Promise<Component>) {
     super()
 
     schemas.get.validate(options)
@@ -26,21 +26,17 @@ export class Get extends Directive {
     this.discovery = discovery
   }
 
-  public async apply (storage: string, input: Input): Promise<Output> {
+  public async apply(storage: string, input: Input): Promise<Output> {
     this.storage ??= await this.discovery
 
     if (input.subtype === 'octets.entry')
-      if (this.options.meta)
-        return this.head(storage, input)
-      else
-        throw new Forbidden('Metadata is not accessible')
-    else
-      return await this.get(storage, input)
+      if (this.options.meta) return this.head(storage, input)
+      else throw new Forbidden('Metadata is not accessible')
+    else return await this.get(storage, input)
   }
 
-  private async get (storage: string, input: Input): Promise<Output> {
-    if ('if-none-match' in input.request.headers)
-      return { status: 304 }
+  private async get(storage: string, input: Input): Promise<Output> {
+    if ('if-none-match' in input.request.headers) return { status: 304 }
 
     const endpoint = input.request.method === 'GET' ? 'get' : 'head'
 
@@ -53,21 +49,18 @@ export class Get extends Directive {
       }
     })
 
-    if (entry instanceof Error)
-      throw new NotFound()
+    if (entry instanceof Error) throw new NotFound()
 
     const headers = new Headers({
       'content-type': entry.type,
       etag: `"${entry.checksum}"`
     })
 
-    if (entry.range !== undefined)
-      headers.set('content-range', entry.range)
+    if (entry.range !== undefined) headers.set('content-range', entry.range)
 
     // an absent content-length is what says the length is unknown; naming the encoding
     // is redundant over HTTP/1.1 and forbidden over HTTP/2
-    if (entry.size !== null)
-      headers.set('content-length', entry.size.toString())
+    if (entry.size !== null) headers.set('content-length', entry.size.toString())
 
     return {
       status: entry.partial === true ? 206 : 200,
@@ -76,7 +69,7 @@ export class Get extends Directive {
     }
   }
 
-  private async head (storage: string, input: Input): Promise<Output> {
+  private async head(storage: string, input: Input): Promise<Output> {
     const entry = await this.storage.invoke<Maybe<Entry>>('head', {
       input: {
         storage,
@@ -84,8 +77,7 @@ export class Get extends Directive {
       }
     })
 
-    if (entry instanceof Error)
-      throw new NotFound()
+    if (entry instanceof Error) throw new NotFound()
 
     return { body: entry }
   }

package/source/directives/octets/Octets.ts

@@ -17,7 +17,7 @@ export class Octets implements DirectiveFamily<Directive> {
 
   private discovery = null as unknown as Promise<Component>
 
-  public create (name: string, value: any, remotes: Remotes): Directive {
+  public create(name: string, value: any, remotes: Remotes): Directive {
     const Class = DIRECTIVES[name]
 
     if (Class === undefined)
@@ -28,32 +28,33 @@ export class Octets implements DirectiveFamily<Directive> {
     return new Class(value, this.discovery, remotes)
   }
 
-  public async precall (directives: Directive[], input: Input, parameters: Parameter[]): Promise<Output> {
+  public async precall(
+    directives: Directive[],
+    input: Input,
+    parameters: Parameter[]
+  ): Promise<Output> {
     let context: Context | null = null
     let action: Directive | null = null
 
     for (const directive of directives)
-      if (directive instanceof Context)
-        context ??= directive
-      else if (action === null)
-        action = directive
-      else
-        throw new Error('Octets action is ambiguous')
+      if (directive instanceof Context) context ??= directive
+      else if (action === null) action = directive
+      else throw new Error('Octets action is ambiguous')
 
-    if (action === null)
-      return null
+    if (action === null) return null
 
     // noinspection PointlessBooleanExpressionJS
-    if (context === null)
-      throw new Error('Octets context is not defined')
+    if (context === null) throw new Error('Octets context is not defined')
 
     const targeted = input.request.url[input.request.url.length - 1] !== '/'
 
     if (targeted !== action.targeted)
-      throw new NotFound(`Trailing slash is ${action.targeted ? 'redundant' : 'required'}`)
+      throw new NotFound(
+        `Trailing slash is ${action.targeted ? 'redundant' : 'required'}`
+      )
 
     // noinspection JSObjectNullOrUndefined
-    return await input.timing.capture(action.name, action.apply(context.storage, input, parameters))
+    return await action.apply(context.storage, input, parameters)
   }
 }
 
@@ -66,4 +67,8 @@ const DIRECTIVES: Record<string, Constructor> = {
   workflow: WorkflowDirective
 }
 
-type Constructor = new (value: any, discovery: Promise<Component>, remotes: Remotes) => Directive
+type Constructor = new (
+  value: any,
+  discovery: Promise<Component>,
+  remotes: Remotes
+) => Directive

package/source/directives/octets/Put.ts

@@ -27,25 +27,33 @@ export class Put extends Directive {
   private readonly discovery: Record<string, Promise<Component>> = {}
   private storage: Component | null = null
 
-  public constructor (options: Options | null, discovery: Promise<Component>, remotes: Remotes) {
+  public constructor(
+    options: Options | null,
+    discovery: Promise<Component>,
+    remotes: Remotes
+  ) {
     super()
 
     schemas.put.validate<Options>(options)
 
-    this.accept = match(options?.accept,
-      String, (value: string) => value,
-      Array, (types: string[]) => types.join(','),
-      undefined)
+    this.accept = match(
+      options?.accept,
+      String,
+      (value: string) => value,
+      Array,
+      (types: string[]) => types.join(','),
+      undefined
+    )
 
     if (options?.workflow !== undefined)
       this.workflow = new Workflow(options.workflow, remotes)
 
     if (options?.trust !== undefined)
       this.trust = options.trust.map((value: string) =>
-        value.startsWith('/') ? new RegExp(value.slice(1, -1)) : value)
+        value.startsWith('/') ? new RegExp(value.slice(1, -1)) : value
+      )
 
-    if (options?.location !== undefined)
-      this.location = options.location
+    if (options?.location !== undefined) this.location = options.location
 
     this.limitString = options?.limit ?? '64MiB'
     this.limit = toBytes(this.limitString)
@@ -55,7 +63,11 @@ export class Put extends Directive {
     cors.allow('content-location')
   }
 
-  public async apply (storage: string, input: Input, parameters: Parameter[]): Promise<Output> {
+  public async apply(
+    storage: string,
+    input: Input,
+    parameters: Parameter[]
+  ): Promise<Output> {
     this.storage ??= await this.discovery.storage
 
     const request: StoreRequest = {
@@ -71,22 +83,36 @@ export class Put extends Directive {
 
     const entry = await this.storage.invoke<Entry>('put', request)
 
-    return match<Output>(entry,
-      Error, (error: CodedError) => this.throw(error),
-      () => this.reply(input, storage, entry, parameters))
+    return match<Output>(
+      entry,
+      Error,
+      (error: CodedError) => this.throw(error),
+      () => this.reply(input, storage, entry, parameters)
+    )
   }
 
   // eslint-disable-next-line max-params
-  private reply (input: Input, storage: string, entry: Entry, parameters: Parameter[]): Output {
-    const body = this.workflow === undefined
-      ? entry
-      : this.execute(input, storage, entry, parameters)
+  private reply(
+    input: Input,
+    storage: string,
+    entry: Entry,
+    parameters: Parameter[]
+  ): Output {
+    const body =
+      this.workflow === undefined
+        ? entry
+        : 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 {
+  private execute(
+    input: Input,
+    storage: string,
+    entry: Entry,
+    parameters: Parameter[]
+  ): Readable {
     const stream = new PassThrough({ objectMode: true })
 
     stream.push(entry)
@@ -103,16 +129,25 @@ export class Put extends Directive {
     return stream
   }
 
-  private throw (error: CodedError): never {
-    throw match(error.code,
-      'NOT_ACCEPTABLE', () => new http.UnsupportedMediaType(),
-      'TYPE_MISMATCH', () => new http.BadRequest(),
-      'LIMIT_EXCEEDED', () => new http.RequestEntityTooLarge(`Size limit is ${this.limitString}`),
-      'LOCATION_UNTRUSTED', () => new http.Forbidden(error.message),
-      'LOCATION_LENGTH', () => new http.BadRequest(error.message),
-      'LOCATION_UNAVAILABLE', () => new http.NotFound(error.message),
-      'INVALID_ID', () => new http.BadRequest(error.message),
-      error)
+  private throw(error: CodedError): never {
+    throw match(
+      error.code,
+      'NOT_ACCEPTABLE',
+      () => new http.UnsupportedMediaType(),
+      'TYPE_MISMATCH',
+      () => new http.BadRequest(),
+      'LIMIT_EXCEEDED',
+      () => new http.RequestEntityTooLarge(`Size limit is ${this.limitString}`),
+      'LOCATION_UNTRUSTED',
+      () => new http.Forbidden(error.message),
+      'LOCATION_LENGTH',
+      () => new http.BadRequest(error.message),
+      'LOCATION_UNAVAILABLE',
+      () => new http.NotFound(error.message),
+      'INVALID_ID',
+      () => new http.BadRequest(error.message),
+      error
+    )
   }
 }
 

package/source/directives/octets/Workflow.ts

@@ -7,7 +7,7 @@ import type { Input } from './types.js'
 import type { Component } from '@toa.io/core'
 import type { Output } from '../../io.js'
 import type { Remotes } from '../../Remotes.js'
-import type { Maybe } from '@toa.io/core'
+import type { Maybe } from '@toa.io/core/types'
 import type { Entry } from '@toa.io/extensions.storages'
 import type { Parameter } from '../../RTD/index.js'
 
@@ -18,7 +18,11 @@ export class WorkflowDirective extends Directive {
   private readonly discovery: Promise<Component>
   private storage: Component | null = null
 
-  public constructor (units: Unit[] | Unit, discovery: Promise<Component>, remotes: Remotes) {
+  public constructor(
+    units: Unit[] | Unit,
+    discovery: Promise<Component>,
+    remotes: Remotes
+  ) {
     super()
     schemas.workflow.validate(units)
 
@@ -26,19 +30,21 @@ export class WorkflowDirective extends Directive {
     this.discovery = discovery
   }
 
-  public async apply (storage: string, input: 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>>('head',
-      {
-        input: {
-          storage,
-          path: input.request.url
-        }
-      })
+    const entry = await this.storage.invoke<Maybe<Entry>>('head', {
+      input: {
+        storage,
+        path: input.request.url
+      }
+    })
 
-    if (entry instanceof Error)
-      throw new NotFound()
+    if (entry instanceof Error) throw new NotFound()
 
     const location: Location = {
       storage,

package/source/directives/octets/bytes.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert'
 
-export function toBytes (input: string): number {
+export function toBytes(input: string): number {
   const match = RX.exec(input)
 
   assert.ok(match !== null, `Invalid bytes format: ${input}`)

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

@@ -4,23 +4,17 @@ import assert from 'node:assert/strict'
 import * as schemas from './schemas.js'
 
 describe('workflow', () => {
-  const ok = [
-    { echo: 'hello world' },
-    [{ echo: 'hello world' }, { ok: 'ok' }]
-  ]
+  const ok = [{ echo: 'hello world' }, [{ echo: 'hello world' }, { ok: 'ok' }]]
 
-  const oh = [
-    { echo: [] },
-    { echo: 'hello world', ok: { not: 'ok' } }
-  ]
+  const oh = [{ echo: [] }, { echo: 'hello world', ok: { not: 'ok' } }]
 
   for (const workflow of ok)
-     it('should be valid', () => {
-    assert.doesNotThrow(() => schemas.workflow.validate(workflow))
-  })
+    it('should be valid', () => {
+      assert.doesNotThrow(() => schemas.workflow.validate(workflow))
+    })
 
   for (const workflow of oh)
-     it('should not be valid', () => {
-    assert.throws(() => schemas.workflow.validate(workflow))
-  })
+    it('should not be valid', () => {
+      assert.throws(() => schemas.workflow.validate(workflow))
+    })
 })

package/source/directives/octets/workflows/Execution.ts

@@ -3,7 +3,7 @@ import { console } from 'openspan'
 import type { Unit } from './Workflow.js'
 import type { Remotes } from '../../../Remotes.js'
 import type { Component } from '@toa.io/core'
-import type { Maybe } from '@toa.io/core'
+import type { Maybe } from '@toa.io/core/types'
 import type { Entry } from '@toa.io/extensions.storages'
 
 export class Execution extends Readable {
@@ -14,7 +14,7 @@ export class Execution extends Readable {
   private readonly discovery: Record<string, Promise<Component>> = {}
   private interrupted = false
 
-  public constructor (context: Context, units: Unit[], remotes: Remotes) {
+  public constructor(context: Context, units: Unit[], remotes: Remotes) {
     super({ objectMode: true })
 
     this.context = context
@@ -24,27 +24,24 @@ export class Execution extends Readable {
     void this.run()
   }
 
-  public override _read (): void {
-  }
+  public override _read(): void {}
 
-  private async run (): Promise<void> {
+  private async run(): Promise<void> {
     for (const unit of this.units) {
       await this.execute(unit)
 
-      if (this.interrupted)
-        break
+      if (this.interrupted) break
     }
 
     this.push(null)
   }
 
-  private async execute (unit: Unit): Promise<void> {
+  private async execute(unit: Unit): Promise<void> {
     const promises = Object.entries(unit).map(async ([step, endpoint]) => {
       try {
         const result = await this.call(endpoint)
 
-        if (result instanceof Readable)
-          return await this.stream(step, result)
+        if (result instanceof Readable) return await this.stream(step, result)
 
         this.report(step, result)
       } catch (e: unknown) {
@@ -55,10 +52,9 @@ export class Execution extends Readable {
     await Promise.all(promises)
   }
 
-  private async stream (step: string, stream: Readable): Promise<void> {
+  private async stream(step: string, stream: Readable): Promise<void> {
     try {
-      for await (const result of stream)
-        this.report(step, result, false)
+      for await (const result of stream) this.report(step, result, false)
 
       this.report(step, undefined, true)
     } catch (e: unknown) {
@@ -66,11 +62,10 @@ export class Execution extends Readable {
     }
   }
 
-  private report (step: string, result?: Maybe<unknown>, completed = true): void {
+  private report(step: string, result?: Maybe<unknown>, completed = true): void {
     const report: Report = { step }
 
-    if (completed)
-      report.status = 'completed'
+    if (completed) report.status = 'completed'
 
     if (result instanceof Error) {
       // an Error cannot be serialized where it sits, and the encoders only unwrap
@@ -85,18 +80,17 @@ export class Execution extends Readable {
     this.push(report)
   }
 
-  private exception (step: string, error: unknown): void {
+  private exception(step: string, error: unknown): void {
     console.error('Workflow exception', error as Error)
 
     this.push({ step, status: 'exception' } satisfies Report)
     this.interrupted = true
   }
 
-  private async call (endpoint: string): Promise<Maybe<unknown>> {
+  private async call(endpoint: string): Promise<Maybe<unknown>> {
     const task = endpoint.startsWith('task:')
 
-    if (task)
-      endpoint = endpoint.slice(5)
+    if (task) endpoint = endpoint.slice(5)
 
     const [operation, component, namespace = 'default'] = endpoint.split('.').reverse()
     const key = `${namespace}.${component}`
@@ -106,7 +100,11 @@ export class Execution extends Readable {
     return this.components[key].invoke(operation, { input: this.context, task })
   }
 
-  private async discover (key: string, namespace: string, component: string): Promise<Component> {
+  private async discover(
+    key: string,
+    namespace: string,
+    component: string
+  ): Promise<Component> {
     if (this.discovery[key] === undefined)
       this.discovery[key] = this.remotes.discover(namespace, component)
 

package/source/directives/octets/workflows/Workflow.ts

@@ -10,19 +10,22 @@ export class Workflow {
   private readonly units: Unit[]
   private readonly remotes: Remotes
 
-  public constructor (units: Unit[] | Unit, remotes: Remotes) {
-    this.units = match<Unit[]>(units,
-      Array, (units: Unit[]) => units,
-      Object, (unit: Unit) => [unit])
+  public constructor(units: Unit[] | Unit, remotes: Remotes) {
+    this.units = match<Unit[]>(
+      units,
+      Array,
+      (units: Unit[]) => units,
+      Object,
+      (unit: Unit) => [unit]
+    )
 
     this.remotes = remotes
   }
 
-  public execute (location: Location, entry: Entry, params: Parameter[]): Execution {
+  public execute(location: Location, entry: Entry, params: Parameter[]): Execution {
     const parameters: Record<string, string> = {}
 
-    for (const { name, value } of params)
-      parameters[name] = value
+    for (const { name, value } of params) parameters[name] = value
 
     const context: Context = {
       authority: location.authority,

package/source/directives/require/Headers.ts

@@ -5,14 +5,13 @@ import type { Directive } from './Directive.js'
 export class Headers implements Directive {
   private readonly headers: string[]
 
-  public constructor (headers: string[]) {
-    if (!Array.isArray(headers))
-      headers = [headers]
+  public constructor(headers: string[]) {
+    if (!Array.isArray(headers)) headers = [headers]
 
     this.headers = headers
   }
 
-  public precall (context: Input): void {
+  public precall(context: Input): void {
     for (const header of this.headers)
       if (context.request.headers[header] === undefined)
         throw new BadRequest(`Header required: ${header}`)

package/source/directives/require/Require.ts

@@ -8,15 +8,14 @@ export class Require implements DirectiveFamily {
   public readonly name = 'require'
   public readonly mandatory = false
 
-  public create (name: string, value: unknown): Directive {
+  public create(name: string, value: unknown): Directive {
     assert.ok(name in directives, `Unknown directive: require:${name}`)
 
     return new directives[name](value)
   }
 
-  public precall (instances: Directive[], context: Input): null {
-    for (const instance of instances)
-      instance.precall(context)
+  public precall(instances: Directive[], context: Input): null {
+    for (const instance of instances) instance.precall(context)
 
     return null
   }

package/source/exceptions.ts

@@ -4,26 +4,33 @@ import * as http from './HTTP/index.js'
 import { Exception as HTTPException } from './HTTP/index.js'
 import type { Exception } from '@toa.io/core'
 
-export function rethrow (exception: Exception | HTTPException): void {
-  if (exception instanceof HTTPException)
-    throw exception
+export function rethrow(exception: Exception | HTTPException): void {
+  if (exception instanceof HTTPException) throw exception
 
   // see /runtime/core/src/exceptions.js
-  throw match(exception.code,
-    badRequest, () => new http.BadRequest(exception.message),
-    CORE_EXCEPTIONS.StateNotFound, NOT_FOUND,
-    CORE_EXCEPTIONS.StatePrecondition, PRECONDITION_FAILED,
-    CORE_EXCEPTIONS.Duplicate, CONFLICT,
-    CORE_EXCEPTIONS.StateConcurrency, CONFLICT,
-    CORE_EXCEPTIONS.EntityGuard, CONFLICT,
+  throw match(
+    exception.code,
+    badRequest,
+    () => new http.BadRequest(exception.message),
+    CORE_EXCEPTIONS.StateNotFound,
+    NOT_FOUND,
+    CORE_EXCEPTIONS.StatePrecondition,
+    PRECONDITION_FAILED,
+    CORE_EXCEPTIONS.Duplicate,
+    CONFLICT,
+    CORE_EXCEPTIONS.StateConcurrency,
+    CONFLICT,
+    CORE_EXCEPTIONS.EntityGuard,
+    CONFLICT,
     () => {
       console.error('Request processing exception', exception)
 
       return exception
-    })
+    }
+  )
 }
 
-function badRequest (code: number): boolean {
+function badRequest(code: number): boolean {
   return (code >= 200 && code < 210) || code === 221
 }
 

package/source/index.ts

@@ -1,5 +1,5 @@
 export { manifest } from './manifest.js'
-export { deployment } from './deployment.js'
+export { deployment, image } from './deployment.js'
 export { components } from './Composition.js'
 export { Factory } from './Factory.js'
 

package/source/manifest.test.ts

@@ -38,7 +38,10 @@ it('should not create node for default namespace', async () => {
 })
 
 it('should throw on invalid declaration type', async () => {
-  assert.throws(() => manifest('hello' as unknown as object, mf), (error: any) => /Exposition declaration must be an object/.test(error.message))
+  assert.throws(
+    () => manifest('hello' as unknown as object, mf),
+    (error: any) => /Exposition declaration must be an object/.test(error.message)
+  )
 })
 
 it('should set namespace and component', async () => {