@toa.io/extensions.exposition 1.0.0-alpha.31 → 1.0.0-alpha.310

package/source/directives/octets/List.ts

@@ -1,72 +0,0 @@
-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 '../../io'
-
-import type { Input } from './types'
-
-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 (permissions: Permissions | null, discovery: Promise<Component>) {
-    super()
-    schemas.list.validate(permissions)
-
-    Object.assign(this.permissions, permissions)
-    this.discovery = discovery
-  }
-
-  public async apply (storage: string, input: Input): Promise<Output> {
-    this.storage ??= await this.discovery
-
-    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()
-
-    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/Octets.ts

@@ -1,71 +0,0 @@
-import { NotFound } from '../../HTTP'
-import { Context } from './Context'
-import { Store } from './Store'
-import { Fetch } from './Fetch'
-import { List } from './List'
-import { Delete } from './Delete'
-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 { Parameter, DirectiveFamily } from '../../RTD'
-import type { Input } from './types'
-
-export class Octets implements DirectiveFamily<Directive> {
-  public readonly name: string = 'octets'
-  public readonly mandatory: boolean = false
-
-  private discovery = null as unknown as Promise<Component>
-
-  public create (name: string, value: any, remotes: Remotes): Directive {
-    const Class = DIRECTIVES[name]
-
-    if (Class === undefined)
-      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, 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 umbiguous.')
-
-    if (action === null)
-      return null
-
-    // noinspection PointlessBooleanExpressionJS
-    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'}.`)
-
-    // 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,
-  delete: Delete,
-  workflow: WorkflowDirective
-}
-
-type Constructor = new (value: any, discovery: Promise<Component>, remotes: Remotes) => Directive

package/source/directives/octets/Store.ts

@@ -1,126 +0,0 @@
-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 './workflows'
-import { Directive } from './Directive'
-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 Store extends Directive {
-  public readonly targeted = false
-
-  private readonly accept?: string
-  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.store.validate(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)
-
-    this.discovery.storage = discovery
-
-    cors.allow('content-meta')
-  }
-
-  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
-      }
-    }
-
-    const meta = input.request.headers['content-meta']
-
-    if (this.accept !== undefined)
-      request.input.accept = this.accept
-
-    if (meta !== undefined)
-      request.input.meta = this.parseMeta(meta)
-
-    const entry = await this.storage.invoke<Entry>('store', 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 UnsupportedMediaType(),
-      'TYPE_MISMATCH', () => new BadRequest(),
-      error)
-  }
-
-  private parseMeta (value: string | string[]): Record<string, string> {
-    if (Array.isArray(value))
-      value = value.join(',')
-
-    const meta: Record<string, string> = {}
-
-    for (const pair of value.split(',')) {
-      const eq = pair.indexOf('=')
-      const key = (eq === -1 ? pair : pair.slice(0, eq)).trim()
-
-      meta[key] = eq === -1 ? 'true' : pair.slice(eq + 1).trim()
-    }
-
-    return meta
-  }
-}
-
-export interface Options {
-  accept?: string | string[]
-  workflow?: Unit[] | Unit
-}
-
-interface StoreRequest {
-  input: {
-    storage: string
-    request: Input['request']
-    accept?: string
-    meta?: Record<string, string>
-  }
-}

package/source/directives/octets/Workflow.ts

@@ -1,48 +0,0 @@
-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>>('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/index.ts

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

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

@@ -1,21 +0,0 @@
-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,19 +0,0 @@
-import { resolve } from 'node:path'
-import schemas from '@toa.io/schemas'
-import type { Permissions as FetchPermissions } from './Fetch'
-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)
-
-export const context: Schema<string> = namespace.schema('context')
-export const store: Schema<StoreOptions | null> = namespace.schema('store')
-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/types.ts

@@ -1,7 +0,0 @@
-import type * as io from '../../io'
-
-export interface Extension {
-  octets?: string
-}
-
-export type Input = io.Input & Extension

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

@@ -1,76 +0,0 @@
-import { Readable } from 'stream'
-import type { Unit } from './Workflow'
-import type { Remotes } from '../../../Remotes'
-import type { Component } from '@toa.io/core'
-import type { Maybe } from '@toa.io/types'
-import type { Entry } from '@toa.io/extensions.storages'
-
-export class Execution extends Readable {
-  private readonly units: Unit[]
-  private readonly remotes: Remotes
-  private readonly context: Context
-  private readonly components: Record<string, Component> = {}
-  private readonly discovery: Record<string, Promise<Component>> = {}
-  private interrupted = false
-
-  public constructor (context: Context, units: Unit[], remotes: Remotes) {
-    super({ objectMode: true })
-
-    this.context = context
-    this.units = units
-    this.remotes = remotes
-
-    void this.run()
-  }
-
-  public override _read (): void {
-  }
-
-  private async run (): Promise<void> {
-    for (const unit of this.units) {
-      await this.execute(unit)
-
-      if (this.interrupted)
-        break
-    }
-
-    this.push(null)
-  }
-
-  private async execute (unit: Unit): Promise<void> {
-    const promises = Object.entries(unit).map(async ([step, endpoint]) => {
-      const result = await this.call(endpoint).catch((error: Error) => console.error(error))
-
-      if (result instanceof Error) {
-        this.push({ error: { step, ...result } })
-        this.interrupted = true
-      } else
-        this.push({ [step]: result ?? null })
-    })
-
-    await Promise.all(promises)
-  }
-
-  private async call (endpoint: string): Promise<Maybe<unknown>> {
-    const [operation, component, namespace = 'default'] = endpoint.split('.').reverse()
-    const key = `${namespace}.${component}`
-
-    this.components[key] ??= await this.discover(key, namespace, component)
-
-    return await this.components[key].invoke(operation, { input: this.context })
-  }
-
-  private async discover (key: string, namespace: string, component: string): Promise<Component> {
-    if (this.discovery[key] === undefined)
-      this.discovery[key] = this.remotes.discover(namespace, component)
-
-    return await this.discovery[key]
-  }
-}
-
-export interface Context {
-  storage: string
-  path: string
-  entry: Entry
-  parameters: Record<string, string>
-}

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

@@ -1,37 +0,0 @@
-import { posix } from 'node:path'
-import { match } from 'matchacho'
-import { Execution } from './Execution'
-import type { Context } from './Execution'
-import type { Parameter } from '../../../RTD'
-import type { Input } from '../types'
-import type { Entry } from '@toa.io/extensions.storages'
-import type { Remotes } from '../../../Remotes'
-
-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])
-
-    this.remotes = remotes
-  }
-
-  // eslint-disable-next-line max-params
-  public execute
-  (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)
-      parameters[name] = value
-
-    const context: Context = { storage, path, entry, parameters }
-
-    return new Execution(context, this.units, this.remotes)
-  }
-}
-
-export type Unit = Record<string, string>

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

@@ -1 +0,0 @@
-export { Workflow, type Unit } from './Workflow'

package/source/directives/require/Directive.ts

@@ -1,5 +0,0 @@
-import type { Input } from '../../io'
-
-export interface Directive {
-  preflight: (context: Input) => void
-}

package/source/directives/require/Headers.ts

@@ -1,20 +0,0 @@
-import { BadRequest } from '../../HTTP'
-import type { Input } from '../../io'
-import type { Directive } from './Directive'
-
-export class Headers implements Directive {
-  private readonly headers: string[]
-
-  public constructor (headers: string[]) {
-    if (!Array.isArray(headers))
-      headers = [headers]
-
-    this.headers = headers
-  }
-
-  public preflight (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

@@ -1,28 +0,0 @@
-import assert from 'node:assert'
-import { Headers } from './Headers'
-import type { Input } from '../../io'
-import type { Directive } from './Directive'
-import type { DirectiveFamily } from '../../RTD'
-
-export class Require implements DirectiveFamily {
-  public readonly name = 'require'
-  public readonly mandatory = false
-
-  public create (name: string, value: unknown): Directive {
-    assert.ok(name in directives, `Unknown directive: require:${name}`)
-
-    return new directives[name](value)
-  }
-
-  public preflight (instances: Directive[], context: Input): null {
-    for (const instance of instances)
-      instance.preflight(context)
-
-    return null
-  }
-}
-
-const directives: Record<string, new (value: any) => Directive> = {
-  header: Headers,
-  headers: Headers
-}

package/source/directives/require/index.ts

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

package/source/directives/vary/Directive.ts

@@ -1,7 +0,0 @@
-import type { Properties } from './Properties'
-import type { Input } from '../../io'
-import type { Parameter } from '../../RTD'
-
-export interface Directive {
-  preflight: (context: Input, properties: Properties, parameters: Parameter[]) => void
-}

package/source/directives/vary/Embed.ts

@@ -1,68 +0,0 @@
-import assert from 'node:assert'
-import { Header, embeddings, Parameter } from './embeddings'
-import type { Embedding } from './embeddings'
-import type { Input } from '../../io'
-import type { Directive } from './Directive'
-import type { Properties } from './Properties'
-import type * as RTD from '../../RTD'
-
-export class Embed implements Directive {
-  private readonly embeddings: Array<[string, Embedding[]]> = []
-
-  public constructor (map: Record<string, string | string[]>) {
-    for (const [key, values] of Object.entries(map)) {
-      const names = Array.isArray(values) ? values : [values]
-
-      const instances = names.map((name) => {
-        if (name[0] === ':')
-          return new Header(name.slice(1))
-
-        if (name.slice(0, 2) === '/:')
-          return new Parameter(name.slice(2))
-
-        assert.ok(name in embeddings, `Unknown embedding: ${name}`)
-
-        return new embeddings[name]()
-      })
-
-      this.embeddings.push([key, instances])
-    }
-  }
-
-  public preflight (context: Input, properties: Properties, parameters: RTD.Parameter[]): void {
-    const values: Record<string, unknown> = {}
-
-    for (const [key, instances] of this.embeddings)
-      values[key] = this.resolve(instances, context, properties, parameters)
-
-    context.pipelines.body.push(this.embedding(values))
-  }
-
-  // eslint-disable-next-line max-params
-  private resolve (instances: Embedding[],
-    input: Input,
-    properties: Properties,
-    parameters: RTD.Parameter[]): unknown {
-    let value
-
-    for (const instance of instances) {
-      value = instance.resolve(input, properties, parameters)
-
-      if (value !== undefined)
-        break
-    }
-
-    return value
-  }
-
-  private embedding (values: Record<string, unknown>) {
-    return (body: unknown): object => {
-      if (body === undefined || body === null || typeof body !== 'object')
-        return values
-
-      Object.assign(body, values)
-
-      return body
-    }
-  }
-}

package/source/directives/vary/Properties.ts

@@ -1,17 +0,0 @@
-export interface Properties {
-  languages?: string[]
-}
-
-export class Property<K extends keyof Properties = keyof Properties> {
-  public readonly name: K
-  public readonly value: Properties[K]
-
-  public constructor (name: K, value: Properties[K]) {
-    this.name = name
-    this.value = value
-  }
-}
-
-export const properties: Properties = {
-  languages: []
-}