@toa.io/extensions.exposition 1.0.0-alpha.3 → 1.0.0-alpha.300

package/source/directives/cache/types.ts

@@ -1,9 +0,0 @@
-import type { Input } from '../../io'
-
-export interface Directive {
-  set: (input: Input, headers: Headers) => void
-}
-
-export interface AuthenticatedRequest extends Input {
-  identity?: unknown | null
-}

package/source/directives/cors/CORS.ts

@@ -1,54 +0,0 @@
-import type { Input, Output } from '../../io'
-import type { Interceptor } from '../../Interception'
-
-export class CORS implements Interceptor {
-  public readonly name = 'cors'
-  public readonly mandatory = true
-
-  private readonly allowedHeaders = new Set<string>(['accept', 'authorization', 'content-type'])
-
-  private readonly headers = new Headers({
-    'access-control-allow-methods': 'GET, POST, PUT, PATCH, DELETE',
-    'access-control-allow-credentials': 'true',
-    'access-control-allow-headers': Array.from(this.allowedHeaders).join(', '),
-    'access-control-max-age': '3600',
-    'cache-control': 'public, max-age=3600',
-    vary: 'origin'
-  })
-
-  public intercept (input: Input): Output {
-    const origin = input.headers.origin
-
-    if (origin === undefined)
-      return null
-
-    if (input.method === 'OPTIONS')
-      return this.preflightResponse(origin)
-
-    input.pipelines.response.push((output) => {
-      output.headers ??= new Headers()
-      output.headers.set('access-control-allow-origin', origin)
-      output.headers.set('access-control-expose-headers',
-        'authorization, content-type, content-length, etag')
-
-      if (input.method === 'GET' || input.method === 'HEAD' || input.method === 'OPTIONS')
-        output.headers.append('vary', 'origin')
-    })
-
-    return null
-  }
-
-  public allowHeader (header: string): void {
-    this.allowedHeaders.add(header.toLowerCase())
-    this.headers.set('access-control-allow-headers', Array.from(this.allowedHeaders).join(', '))
-  }
-
-  private preflightResponse (origin: string): Output {
-    this.headers.set('access-control-allow-origin', origin)
-
-    return {
-      status: 204,
-      headers: this.headers
-    }
-  }
-}

package/source/directives/cors/index.ts

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

package/source/directives/dev/Development.ts

@@ -1,35 +0,0 @@
-import { Stub } from './Stub'
-import { Throw } from './Throw'
-import { type Directive } from './types'
-import type { Input, Output } from '../../io'
-import type { Family } from '../../Directive'
-
-export class Development implements Family<Directive> {
-  public readonly name: string = 'dev'
-  public readonly mandatory: boolean = false
-
-  public create (name: string, value: any): Directive {
-    const Class = constructors[name]
-
-    if (Class === undefined)
-      throw new Error(`Directive '${name}' is not provided by the '${this.name}' family.`)
-
-    return new Class(value)
-  }
-
-  public preflight (directives: Directive[], input: Input): Output {
-    for (const directive of directives) {
-      const output = directive.apply(input)
-
-      if (output !== null)
-        return output
-    }
-
-    return null
-  }
-}
-
-const constructors: Record<string, new (value: any) => Directive> = {
-  stub: Stub,
-  throw: Throw
-}

package/source/directives/dev/Stub.ts

@@ -1,14 +0,0 @@
-import type { Output } from '../../io'
-import type { Directive } from './types'
-
-export class Stub implements Directive {
-  private readonly value: unknown
-
-  public constructor (value: unknown) {
-    this.value = value
-  }
-
-  public apply (): Output {
-    return { body: this.value }
-  }
-}

package/source/directives/dev/Throw.ts

@@ -1,14 +0,0 @@
-import type { Output } from '../../io'
-import type { Directive } from './types'
-
-export class Throw implements Directive {
-  private readonly message: string
-
-  public constructor (message: string) {
-    this.message = message
-  }
-
-  public apply (): Output {
-    throw new Error(this.message)
-  }
-}

package/source/directives/dev/index.ts

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

package/source/directives/dev/types.ts

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

package/source/directives/index.ts

@@ -1,11 +0,0 @@
-import { dev } from './dev'
-import { authorization } from './auth'
-import { cache } from './cache'
-import { octets } from './octets'
-import { cors } from './cors'
-import { vary } from './vary'
-import type { Family } from '../Directive'
-import type { Interceptor } from '../Interception'
-
-export const families: Family[] = [authorization, cache, octets, vary, dev]
-export const interceptors: Interceptor[] = [cors]

package/source/directives/octets/Context.ts

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

package/source/directives/octets/Delete.ts

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

package/source/directives/octets/Fetch.ts

@@ -1,84 +0,0 @@
-import { posix } from 'node:path'
-import { Forbidden, NotFound } from '../../HTTP'
-import * as schemas from './schemas'
-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 '../../io'
-
-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 discovery: Promise<Component>
-  private storage: Component = null as unknown as Component
-
-  public constructor (permissions: Permissions | null, discovery: Promise<Component>) {
-    schemas.fetch.validate(permissions)
-
-    Object.assign(this.permissions, permissions)
-    this.discovery = discovery
-  }
-
-  public async apply (storage: string, request: Input): Promise<Output> {
-    this.storage ??= await this.discovery
-
-    const variant = posix.basename(request.url).includes('.')
-    const metadata = request.subtype === 'octets.entry'
-
-    if (!variant && metadata)
-      if (this.permissions.meta)
-        return this.get(storage, request)
-      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)
-  }
-
-  private async fetch (storage: string, request: Input): Promise<Output> {
-    if ('if-none-match' in request.headers)
-      return { status: 304 }
-
-    const input = { storage, path: request.url }
-    const result = await this.storage.invoke<Maybe<FetchResult>>('fetch', { input })
-
-    if (result instanceof Error)
-      throw new NotFound()
-
-    const headers = new Headers({
-      'content-type': result.type,
-      'content-length': result.size.toString(),
-      etag: result.checksum
-    })
-
-    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 })
-
-    if (entry instanceof Error)
-      throw new NotFound()
-
-    return { body: entry }
-  }
-}
-
-export interface Permissions {
-  blob?: boolean
-  meta?: boolean
-}
-
-interface FetchResult {
-  stream: Readable
-  checksum: string
-  size: number
-  type: string
-}

package/source/directives/octets/List.ts

@@ -1,62 +0,0 @@
-import { posix } from 'node:path'
-import { Forbidden, NotFound } from '../../HTTP'
-import * as schemas from './schemas'
-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 { Directive, Input } from './types'
-
-export class List implements 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>) {
-    schemas.list.validate(permissions)
-
-    Object.assign(this.permissions, permissions)
-    this.discovery = discovery
-  }
-
-  public async apply (storage: string, request: Input): Promise<Output> {
-    this.storage ??= await this.discovery
-
-    const metadata = request.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 })
-
-    if (list instanceof Error)
-      throw new NotFound()
-
-    const body = metadata
-      ? await this.expand(storage, 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 { Permute } from './Permute'
-import { WorkflowDirective } from './Workflow'
-import type { Output } from '../../io'
-import type { Component } from '@toa.io/core'
-import type { Remotes } from '../../Remotes'
-import type { Family } from '../../Directive'
-import type { Directive, Input } from './types'
-import type { Parameter } from '../../RTD'
-
-export class Octets implements Family<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 '${name}' is not provided by the '${this.name}' family.`)
-
-    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
-
-    if (context === null)
-      throw new Error('Octets context is not defined.')
-
-    const targeted = input.path[input.path.length - 1] !== '/'
-
-    if (targeted !== action.targeted)
-      throw new NotFound(`Trailing slash is ${action.targeted ? 'redundant' : 'required'}.`)
-
-    return await action.apply(context.storage, input, parameters)
-  }
-}
-
-const DIRECTIVES: Record<string, Constructor> = {
-  context: Context,
-  store: Store,
-  fetch: Fetch,
-  list: List,
-  delete: Delete,
-  permute: Permute,
-  workflow: WorkflowDirective
-}
-
-type Constructor = new (value: any, discovery: Promise<Component>, remotes: Remotes) => Directive

package/source/directives/octets/Permute.ts

@@ -1,37 +0,0 @@
-import { NotAcceptable, NotFound } from '../../HTTP'
-import * as schemas from './schemas'
-import type { Maybe } from '@toa.io/types'
-import type { Component } from '@toa.io/core'
-import type { Output } from '../../io'
-
-import type { Directive, Input } from './types'
-
-export class Permute implements Directive {
-  public readonly targeted = false
-
-  private readonly discovery: Promise<Component>
-  private storage: Component | null = null
-
-  public constructor (value: null, discovery: Promise<Component>) {
-    schemas.permute.validate(value)
-
-    this.discovery = discovery
-  }
-
-  public async apply (storage: string, request: Input): Promise<Output> {
-    this.storage ??= await this.discovery
-
-    if (request.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 })
-
-    if (error instanceof Error)
-      throw new NotFound()
-
-    return {}
-  }
-}

package/source/directives/octets/Store.ts

@@ -1,116 +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 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 { Directive, Input } from './types'
-
-export class Store implements 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) {
-    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.allowHeader('content-meta')
-  }
-
-  public async apply (storage: string, request: Input, parameters: Parameter[]): Promise<Output> {
-    this.storage ??= await this.discovery.storage
-
-    const input: StoreInput = { storage, request }
-    const meta = request.headers['content-meta']
-
-    if (this.accept !== undefined)
-      input.accept = this.accept
-
-    if (meta !== undefined)
-      input.meta = this.parseMeta(meta)
-
-    const entry = await this.storage.invoke<Entry>('store', { input })
-
-    return match<Output>(entry,
-      Error, (error: ErrorType) => this.throw(error),
-      () => this.reply(request, storage, entry, parameters))
-  }
-
-  // eslint-disable-next-line max-params
-  private reply (request: Input, storage: string, entry: Entry, parameters: Parameter[]): Output {
-    const body = this.workflow === undefined
-      ? entry
-      : this.execute(request, storage, entry, parameters)
-
-    return { body }
-  }
-
-  // eslint-disable-next-line max-params
-  private execute
-  (request: Input, storage: string, entry: Entry, parameters: Parameter[]): Readable {
-    const stream = new PassThrough({ objectMode: true })
-
-    stream.push(entry)
-
-    this.workflow!.execute(request, 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 StoreInput {
-  storage: string
-  request: Input
-  accept?: string
-  meta?: Record<string, string>
-}

package/source/directives/octets/Workflow.ts

@@ -1,41 +0,0 @@
-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, request: Input, parameters: Parameter[]): Promise<Output> {
-    this.storage ??= await this.discovery
-
-    const entry = await this.storage.invoke<Maybe<Entry>>('get',
-      { input: { storage, path: request.url } })
-
-    if (entry instanceof Error)
-      throw new NotFound()
-
-    return {
-      status: 202,
-      body: this.workflow.execute(request, storage, entry, parameters)
-    }
-  }
-}

package/source/directives/octets/index.ts

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