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

package/source/directives/cache/Control.ts

@@ -1,85 +0,0 @@
-import { match } from 'matchacho'
-import type { AuthenticatedContext, Directive } from './types'
-
-export class Control implements Directive {
-  protected readonly value: string
-  private cache: string | null = null
-  private vary: boolean = false
-
-  public constructor (value: string) {
-    this.value = value
-  }
-
-  public set (context: AuthenticatedContext, headers: Headers): void {
-    if (!['GET', 'HEAD', 'OPTIONS'].includes(context.request.method))
-      return
-
-    this.cache ??= this.resolve(context)
-
-    if (this.disabled(headers))
-      return
-
-    headers.append('cache-control', this.cache)
-
-    if (this.vary !== null)
-      headers.append('vary', 'authorization')
-  }
-
-  protected resolve (request: AuthenticatedContext): string {
-    if (request.identity === null)
-      return this.value
-
-    const directives = mask(this.value)
-
-    if ((directives & PRIVATE) === PRIVATE)
-      this.vary = true
-
-    if ((directives & (PUBLIC | NO_CACHE)) === PUBLIC)
-      return 'no-cache, ' + this.value
-
-    if ((directives & (PUBLIC | PRIVATE)) === 0) {
-      this.vary = true
-
-      return 'private, ' + this.value
-    }
-
-    return this.value
-  }
-
-  private disabled (headers: Headers): boolean {
-    const value = headers.get('cache-control')
-
-    if (value === null)
-      return false
-
-    const directives = mask(value)
-
-    return (directives & NO_STORE) === NO_STORE
-  }
-}
-
-function mask (value: string): number {
-  const directives = value.match(DIRECTIVES_RX)
-
-  if (directives === null)
-    return 0
-
-  let mask = 0
-
-  for (const directive of directives)
-    mask |= match<number>(directive,
-      'private', PRIVATE,
-      'public', PUBLIC,
-      'no-cache', NO_CACHE,
-      'no-store', NO_STORE,
-      0)
-
-  return mask
-}
-
-const DIRECTIVES_RX = /\b(private|public|no-cache|no-store)\b/ig
-
-const PUBLIC = 1
-const PRIVATE = 2
-const NO_CACHE = 4
-const NO_STORE = 8

package/source/directives/cache/Exact.ts

@@ -1,7 +0,0 @@
-import { Control } from './Control'
-
-export class Exact extends Control {
-  protected override resolve (): string {
-    return this.value
-  }
-}

package/source/directives/cache/index.ts

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

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 AuthenticatedContext extends Input {
-  identity?: unknown | null
-}

package/source/directives/cors/CORS.ts

@@ -1,62 +0,0 @@
-import type { Input, Output } from '../../io'
-import type { Interceptor } from '../../Interception'
-
-export class CORS implements Interceptor {
-  public readonly name = 'cors'
-
-  private readonly requestHeaders = new Set<string>([
-    'accept',
-    'authorization',
-    'content-type',
-    'etag',
-    'if-match',
-    'if-none-match'
-  ])
-
-  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.requestHeaders).join(', '),
-    'access-control-max-age': '3600',
-    'cache-control': 'max-age=3600',
-    vary: 'origin'
-  })
-
-  public intercept (input: Input): Output {
-    const origin = input.request.headers.origin
-
-    if (origin === undefined)
-      return null
-
-    if (input.request.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')
-
-      const method = input.request.method
-
-      if (method === 'GET' || method === 'HEAD' || method === 'OPTIONS')
-        output.headers.append('vary', 'origin')
-    })
-
-    return null
-  }
-
-  public allow (header: string): void {
-    this.requestHeaders.add(header.toLowerCase())
-    this.headers.set('access-control-allow-headers', Array.from(this.requestHeaders).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 { DirectiveFamily } from '../../RTD'
-
-export class Development implements DirectiveFamily<Directive> {
-  public readonly name: string = 'dev'
-  public readonly mandatory: boolean = false
-
-  public create (name: string, value: unknown): Directive {
-    const Class = constructors[name]
-
-    if (Class === undefined)
-      throw new Error(`Directive 'dev:${name}' is not implemented.`)
-
-    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,13 +0,0 @@
-import { authorization } from './auth'
-import { cache } from './cache'
-import { cors } from './cors'
-import { dev } from './dev'
-import { octets } from './octets'
-import { io } from './io'
-import { vary } from './vary'
-import { req } from './require'
-import type { DirectiveFamily } from '../RTD'
-import type { Interceptor } from '../Interception'
-
-export const families: DirectiveFamily[] = [authorization, io, cache, vary, req, octets, dev]
-export const interceptors: Interceptor[] = [cors]

package/source/directives/io/Directive.ts

@@ -1,11 +0,0 @@
-import type { Input } from '../../io'
-
-export interface Directive {
-  attach: (context: Input) => void
-}
-
-export interface Constructor {
-  validate: (value: unknown) => void
-
-  new (value: any): Directive
-}

package/source/directives/io/IO.ts

@@ -1,43 +0,0 @@
-import { Output } from './Output'
-import { Input } from './Input'
-import type { Constructor, Directive } from './Directive'
-import type { Input as Context } from '../../io'
-import type { DirectiveFamily } from '../../RTD'
-
-export class IO implements DirectiveFamily<Directive> {
-  public readonly name = 'io'
-  public readonly mandatory = true
-
-  public create (name: string, value: unknown): Directive {
-    if (!(name in constructors))
-      throw new Error(`Directive 'io:${name}' is not implemented.`)
-
-    const Directive = constructors[name]
-
-    Directive.validate(value)
-
-    return new Directive(value)
-  }
-
-  public preflight (directives: Directive[], context: Context): null {
-    let restricted = false
-
-    for (const directive of directives) {
-      restricted ||= directive instanceof Output
-
-      directive.attach(context)
-    }
-
-    if (!restricted)
-      DENIAL.attach(context)
-
-    return null
-  }
-}
-
-const constructors: Record<string, Constructor> = {
-  output: Output,
-  input: Input
-}
-
-const DENIAL: Output = new Output([])

package/source/directives/io/Input.ts

@@ -1,50 +0,0 @@
-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

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

package/source/directives/io/Output.ts

@@ -1,69 +0,0 @@
-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

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

package/source/directives/io/schemas.ts

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

package/source/directives/octets/Delete.ts

@@ -1,85 +0,0 @@
-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 '../../io'
-import type { Input } from './types'
-import type { Remotes } from '../../Remotes'
-import type { Entry } from '@toa.io/extensions.storages'
-
-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 (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, 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()
-
-    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

@@ -1,10 +0,0 @@
-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,100 +0,0 @@
-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 '../../io'
-import type { Input } from './types'
-
-export class Fetch extends 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>) {
-    super()
-    schemas.fetch.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 variant = posix.basename(input.request.url).includes('.')
-    const metadata = input.subtype === 'octets.entry'
-
-    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.')
-
-    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 result = await this.storage.invoke<Maybe<FetchResult>>('fetch', {
-      input: {
-        storage,
-        path: input.request.url
-      }
-    })
-
-    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, 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()
-
-    return { body: entry }
-  }
-}
-
-export interface Permissions {
-  blob?: boolean
-  meta?: boolean
-}
-
-interface FetchResult {
-  stream: Readable
-  checksum: string
-  size: number
-  type: string
-}