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

package/source/directives/map/Segments.ts

@@ -0,0 +1,26 @@
+import assert from 'node:assert'
+import { Mapping } from './Mapping'
+import type { Parameter } from '../../RTD'
+
+export class Segments extends Mapping<Record<string, string>> {
+  public constructor (map: Record<string, string>) {
+    assert.ok(map.constructor === Object, '`map:segments` must be an object')
+
+    assert.ok(Object.values(map).every((value) => typeof value === 'string'),
+      '`map:segments ` must be an object with string values')
+
+    super(map)
+  }
+
+  public override properties (_: unknown, parameters: Parameter[]): Record<string, string> {
+    return Object.entries(this.value).reduce((properties: Record<string, string>, [property, parameter]) => {
+      const value = parameters.find(({ name }) => name === parameter)?.value
+
+      assert.ok(value !== undefined, `Route parameter '${parameter}' is missing`)
+
+      properties[property] = value
+
+      return properties
+    }, {})
+  }
+}

package/source/directives/map/index.ts

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

package/source/directives/octets/Context.ts

@@ -1,18 +1,20 @@
-import * as schemas from './schemas'
-import type { Output } from '../../Directive'
-import type { Directive } from './types'
+import assert from 'node:assert'
+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) {
-    schemas.context.validate(value)
+  public constructor (value: unknown) {
+    super()
+
+    assert.ok(typeof value === 'string', 'Directive \'octets:context\' must must be a string')
 
     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 output: Output = {}
+
+    if (this.workflow !== undefined) {
+      const entry = await this.storage.invoke<Maybe<Entry>>('head',
+        {
+          input: {
+            storage,
+            path: input.request.url
+          }
+        })
+
+      if (entry instanceof Error)
+        throw new NotFound()
+
+      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
+        }
+      })
+  }
 
-    if (error instanceof Error)
-      throw new NotFound()
+  // 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
 
-    return {}
+      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/Get.ts

@@ -0,0 +1,86 @@
+import { Forbidden, NotFound } from '../../HTTP'
+import * as schemas from './schemas'
+import { Directive } from './Directive'
+import type { Maybe } from '@toa.io/types'
+import type { Entry, Stream } from '@toa.io/extensions.storages'
+import type { Component } from '@toa.io/core'
+import type { Output } from '../../io'
+import type { Input } from './types'
+
+export class Get extends Directive {
+  public readonly targeted = true
+
+  private readonly options: Required<Options> = {
+    meta: false
+  }
+
+  private readonly discovery: Promise<Component>
+  private storage!: Component
+
+  public constructor (options: Options | null, discovery: Promise<Component>) {
+    super()
+
+    schemas.get.validate(options)
+    Object.assign(this.options, options)
+
+    this.discovery = discovery
+  }
+
+  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)
+  }
+
+  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'
+
+    const entry = await this.storage.invoke<Maybe<Stream>>(endpoint, {
+      input: {
+        storage,
+        path: input.request.url
+      }
+    })
+
+    if (entry instanceof Error)
+      throw new NotFound()
+
+    const headers = new Headers({
+      'content-type': entry.type,
+      'content-length': entry.size.toString(),
+      etag: `"${entry.checksum}"`
+    })
+
+    return {
+      headers,
+      body: endpoint === 'get' ? entry.stream : undefined
+    }
+  }
+
+  private async head (storage: string, input: Input): Promise<Output> {
+    const entry = await this.storage.invoke<Maybe<Entry>>('head', {
+      input: {
+        storage,
+        path: input.request.url
+      }
+    })
+
+    if (entry instanceof Error)
+      throw new NotFound()
+
+    return { body: entry }
+  }
+}
+
+export interface Options {
+  meta?: boolean
+}

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

@@ -1,16 +1,17 @@
 import { NotFound } from '../../HTTP'
 import { Context } from './Context'
-import { Store } from './Store'
-import { Fetch } from './Fetch'
-import { List } from './List'
+import { Put } from './Put'
+import { Get } from './Get'
 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
 
@@ -20,14 +21,15 @@ class Octets implements Family<Directive> {
     const Class = DIRECTIVES[name]
 
     if (Class === undefined)
-      throw new Error(`Directive '${name}' is not provided by the '${this.name}' family.`)
+      throw new Error(`Directive 'octets:${name}' is not implemented`)
 
     this.discovery ??= remotes.discover('octets', 'storage')
 
     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
 
@@ -37,32 +39,32 @@ class Octets implements Family<Directive> {
       else if (action === null)
         action = directive
       else
-        throw new Error('Octets action is umbiguous.')
+        throw new Error('Octets action is ambiguous')
 
     if (action === null)
       return null
 
+    // noinspection PointlessBooleanExpressionJS
     if (context === null)
-      throw new Error('Octets context is not defined.')
+      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'}.`)
+      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))
   }
 }
 
 const DIRECTIVES: Record<string, Constructor> = {
   context: Context,
-  store: Store,
-  fetch: Fetch,
-  list: List,
+  put: Put,
+  get: Get,
+  head: Get,
   delete: Delete,
-  permute: Permute
+  workflow: WorkflowDirective
 }
 
 type Constructor = new (value: any, discovery: Promise<Component>, remotes: Remotes) => Directive
-
-export = new Octets()

package/source/directives/octets/Put.ts

@@ -0,0 +1,142 @@
+import { PassThrough } from 'node:stream'
+import { match } from 'matchacho'
+import * as http from '../../HTTP'
+import { cors } from '../cors'
+import * as schemas from './schemas'
+import { Workflow } from './workflows'
+import { Directive } from './Directive'
+import { toBytes } from './bytes'
+import type { Readable } from 'stream'
+import type { Parameter } from '../../RTD'
+import type { Unit } from './workflows'
+import type { Entry } from '@toa.io/extensions.storages'
+import type { Remotes } from '../../Remotes'
+import type { ErrorType } from 'error-value'
+import type { Component } from '@toa.io/core'
+import type { Output } from '../../io'
+import type { Input } from './types'
+
+export class Put extends Directive {
+  public readonly targeted = false
+
+  private readonly accept?: string
+  private readonly limit: number
+  private readonly limitString: string
+  private readonly trust?: Array<string | RegExp>
+  private readonly workflow?: Workflow
+  private readonly discovery: Record<string, Promise<Component>> = {}
+  private storage: Component | null = null
+
+  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)
+
+    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)
+
+    this.limitString = options?.limit ?? '64MiB'
+    this.limit = toBytes(this.limitString)
+    this.discovery.storage = discovery
+
+    cors.allow('content-attributes')
+    cors.allow('content-location')
+  }
+
+  public async apply (storage: string, input: Input, parameters: Parameter[]): Promise<Output> {
+    this.storage ??= await this.discovery.storage
+
+    const request: StoreRequest = {
+      input: {
+        storage,
+        request: input.request,
+        accept: this.accept,
+        limit: this.limit,
+        trust: this.trust
+      }
+    }
+
+    const entry = await this.storage.invoke<Entry>('put', request)
+
+    return match<Output>(entry,
+      Error, (error: ErrorType) => 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)
+
+    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 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 attributes (value: string | string[]): Record<string, string> {
+    if (Array.isArray(value))
+      value = value.join(',')
+
+    const attributes: Record<string, string> = {}
+
+    for (const pair of value.split(',')) {
+      const eq = pair.indexOf('=')
+      const key = (eq === -1 ? pair : pair.slice(0, eq)).trim()
+
+      attributes[key] = eq === -1 ? 'true' : pair.slice(eq + 1).trim()
+    }
+
+    return attributes
+  }
+}
+
+export interface Options {
+  accept?: string | string[]
+  limit?: string
+  workflow?: Unit[] | Unit
+  trust?: string[]
+}
+
+interface StoreRequest {
+  input: {
+    storage: string
+    request: Input['request']
+    accept?: string
+    limit?: number
+    trust?: Array<string | RegExp>
+    attributes?: Record<string, string>
+  }
+}

package/source/directives/octets/Workflow.ts

@@ -0,0 +1,48 @@
+import { NotFound } from '../../HTTP'
+import * as schemas from './schemas'
+import { Workflow } from './workflows'
+import { Directive } from './Directive'
+import type { Unit } from './workflows'
+import type { 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 extends 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) {
+    super()
+    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>>('head',
+      {
+        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/bytes.test.ts

@@ -0,0 +1,30 @@
+import { toBytes } from './bytes'
+
+it('should parse bytes', async () => {
+  expect(toBytes('10')).toBe(10)
+  expect(toBytes('10B')).toBe(10)
+})
+
+it('should parse binary prefix', async () => {
+  expect(toBytes('10KiB')).toBe(10240)
+  expect(toBytes('10MiB')).toBe(10485760)
+  expect(toBytes('10GiB')).toBe(10737418240)
+  expect(toBytes('10TiB')).toBe(10995116277760)
+})
+
+it('should parse decimal prefix', async () => {
+  expect(toBytes('10kB')).toBe(10000)
+  expect(toBytes('10MB')).toBe(10000000)
+  expect(toBytes('10GB')).toBe(10000000000)
+  expect(toBytes('10TB')).toBe(10000000000000)
+})
+
+it('should parse incorrect value as binary', async () => {
+  expect(toBytes('10b')).toBe(10)
+  expect(toBytes('10kb')).toBe(10240)
+  expect(toBytes('10kib')).toBe(10240)
+  expect(toBytes('10mb')).toBe(10485760)
+  expect(toBytes('10gb')).toBe(10737418240)
+  expect(toBytes('10tib')).toBe(10995116277760)
+  expect(toBytes('10Mb')).toBe(10485760)
+})

package/source/directives/octets/bytes.ts

@@ -0,0 +1,18 @@
+import assert from 'node:assert'
+
+export function toBytes (input: string): number {
+  const match = RX.exec(input)
+
+  assert.ok(match !== null, `Invalid bytes format: ${input}`)
+
+  const value = parseFloat(match.groups!.value)
+  const prefix = match.groups!.prefix?.[0].toLowerCase() ?? ''
+  const binary = match.groups!.binary !== undefined || match.groups!.unit === 'b'
+  const base = binary ? 1024 : 1000
+  const power = POWERS.indexOf(prefix)
+
+  return value * Math.pow(base, power)
+}
+
+const POWERS = ['', 'k', 'm', 'g', 't']
+const RX = /^(?<value>(\d+)(\.\d+)?)(?<prefix>[kmgt](?<binary>i)?)?(?<unit>b)?$/i

package/source/directives/octets/index.ts

@@ -1,3 +1,3 @@
-import Family from './Family'
+import { Octets } from './Octets'
 
-export = Family
+export const octets = new Octets()

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

@@ -1,12 +1,15 @@
 import { resolve } from 'node:path'
 import schemas from '@toa.io/schemas'
+import type { Options as GetOptions } from './Get'
+import type { Options as PutOptions } from './Put'
+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)
 
-export const context = namespace.schema('context')
-export const store = namespace.schema('store')
-export const fetch = namespace.schema('fetch')
-export const remove = namespace.schema('delete')
-export const list = namespace.schema('list')
-export const permute = namespace.schema('permute')
+export const put: Schema<PutOptions | null> = namespace.schema('put')
+export const get: Schema<GetOptions | null> = namespace.schema('get')
+export const remove: Schema<DeleteOptions | null> = namespace.schema('delete')
+export const workflow: Schema<Unit[] | Unit> = namespace.schema('workflow')

package/source/directives/octets/types.ts

@@ -1,13 +1,7 @@
-import type * as directive from '../../Directive'
-
-export interface Directive {
-  readonly targeted: boolean
-
-  apply: (storage: string, input: Input) => directive.Output | Promise<directive.Output>
-}
+import type * as io from '../../io'
 
 export interface Extension {
   octets?: string
 }
 
-export type Input = directive.Input & Extension
+export type Input = io.Input & Extension