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

package/source/directives/auth/Family.ts

@@ -1,148 +0,0 @@
-import { match } from 'matchacho'
-import * as http from '../../HTTP'
-import { Anonymous } from './Anonymous'
-import { Id } from './Id'
-import { Role } from './Role'
-import { Rule } from './Rule'
-import { Incept } from './Incept'
-import { Echo } from './Echo'
-import { split } from './split'
-import { Scheme } from './Scheme'
-import { PRIMARY, PROVIDERS } from './schemes'
-import type { Component } from '@toa.io/core'
-import type { Remotes } from '../../Remotes'
-import type { Family, Output } from '../../Directive'
-import type { Parameter } from '../../RTD'
-import type {
-  AuthenticationResult,
-  Ban,
-  Directive,
-  Discovery,
-  Extension,
-  Identity,
-  Input,
-  Remote,
-  Schemes
-} from './types'
-
-class Authorization implements Family<Directive, Extension> {
-  public readonly name: string = 'auth'
-  public readonly mandatory: boolean = true
-
-  private readonly schemes = {} as unknown as Schemes
-  private readonly discovery = {} as unknown as Discovery
-  private tokens: Component | null = null
-  private bans: Component | null = null
-
-  public create (name: string, value: any, remotes: Remotes): Directive {
-    const Class = CLASSES[name]
-
-    if (Class === undefined)
-      throw new Error(`Directive '${name}' is not provided by the '${this.name}' family.`)
-
-    for (const name of REMOTES)
-      this.discovery[name] ??= remotes.discover('identity', name)
-
-    return match(Class,
-      Role, () => new Role(value, this.discovery.roles),
-      Rule, () => new Rule(value, this.create.bind(this)),
-      Incept, () => new Incept(value, this.discovery),
-      () => new Class(value))
-  }
-
-  public async preflight
-  (directives: Directive[], input: Input, parameters: Parameter[]): Promise<Output> {
-    const identity = await this.resolve(input.headers.authorization)
-
-    input.identity = identity
-
-    for (const directive of directives) {
-      const allow = await directive.authorize(identity, input, parameters)
-
-      if (allow)
-        return directive.reply?.(identity) ?? null
-    }
-
-    if (identity === null) throw new http.Unauthorized()
-    else throw new http.Forbidden()
-  }
-
-  public async settle
-  (directives: Directive[], request: Input, response: http.OutgoingMessage): Promise<void> {
-    for (const directive of directives)
-      await directive.settle?.(request, response)
-
-    const identity = request.identity
-
-    if (identity === null)
-      return
-
-    if (identity.scheme === PRIMARY && !identity.refresh)
-      return
-
-    // Role directive may have already set the value
-    if (identity.roles === undefined)
-      await Role.set(identity, this.discovery.roles)
-
-    this.tokens ??= await this.discovery.tokens
-
-    const token = await this.tokens.invoke<string>('encrypt', { input: { identity } })
-    const authorization = `Token ${token}`
-
-    if (response.headers === undefined)
-      response.headers = new Headers()
-
-    response.headers.set('authorization', authorization)
-  }
-
-  private async resolve (authorization: string | undefined): Promise<Identity | null> {
-    if (authorization === undefined)
-      return null
-
-    const [scheme, credentials] = split(authorization)
-    const provider = PROVIDERS[scheme]
-
-    if (!(provider in this.discovery))
-      throw new http.Unauthorized(`Unknown authentication scheme '${scheme}'.`)
-
-    this.schemes[scheme] ??= await this.discovery[provider]
-
-    const result = await this.schemes[scheme]
-      .invoke<AuthenticationResult>('authenticate', { input: credentials })
-
-    if (result instanceof Error)
-      return null
-
-    const identity = result.identity
-
-    if (scheme !== PRIMARY && await this.banned(identity))
-      throw new http.Unauthorized()
-
-    identity.scheme = scheme
-    identity.refresh = result.refresh
-
-    return identity
-  }
-
-  private async banned (identity: Identity): Promise<boolean> {
-    this.bans ??= await this.discovery.bans
-
-    const ban = await this.bans.invoke<Ban>('observe', { query: { id: identity.id } })
-
-    return ban.banned
-  }
-}
-
-const CLASSES: Record<string, new (value: any, argument?: any) => Directive> = {
-  anonymous: Anonymous,
-  id: Id,
-  role: Role,
-  rule: Rule,
-  incept: Incept,
-  scheme: Scheme,
-  echo: Echo
-}
-
-const REMOTES: Remote[] = ['basic', 'tokens', 'roles', 'bans']
-
-export = new Authorization()

package/source/directives/cache/Family.ts

@@ -1,36 +0,0 @@
-import { type Input, type Output, type Family } from '../../Directive'
-import { Control } from './Control'
-import { type Directive } from './types'
-import { Exact } from './Exact'
-import type * as http from '../../HTTP'
-
-class Cache implements Family<Directive> {
-  public readonly name: string = 'cache'
-  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 (): Output {
-    return null
-  }
-
-  public async settle
-  (directives: Directive[], request: Input, response: http.OutgoingMessage): Promise<void> {
-    response.headers ??= new Headers()
-    directives[0]?.set(request, response.headers)
-  }
-}
-
-const constructors: Record<string, new (value: any) => Directive> = {
-  control: Control,
-  exact: Exact
-}
-
-export = new Cache()

package/source/directives/octets/Fetch.ts

@@ -1,85 +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 '../../Directive'
-
-import type { Directive, Input } from './types'
-
-export class Fetch implements Directive {
-  public readonly targeted = true
-
-  private readonly permissions: Permissions = { blob: true, meta: false }
-  private readonly discovery: Promise<Component>
-  private storage: Component = null as unknown as Component
-
-  public constructor (permissions: Partial<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
-
-    if (request.url.slice(-5) === ':meta')
-      return await this.get(storage, request)
-    else
-      return await this.fetch(storage, request)
-  }
-
-  private async fetch (storage: string, request: Input): Promise<Output> {
-    const filename = posix.basename(request.url)
-    const variant = filename.includes('.')
-
-    if (!variant && !this.permissions.blob)
-      throw new Forbidden('BLOB variant must be specified.')
-
-    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> {
-    if (!this.permissions.meta)
-      throw new Forbidden('Metadata is not accessible.')
-
-    const path = request.url.slice(0, -5)
-    const input = { storage, path }
-    const entry = await this.storage.invoke<Maybe<Entry>>('get', { input })
-
-    if (entry instanceof Error)
-      throw new NotFound()
-
-    return { body: entry }
-  }
-}
-
-interface Permissions {
-  blob: boolean
-  meta: boolean
-}
-
-interface FetchResult {
-  stream: Readable
-  checksum: string
-  size: number
-  type: string
-}

package/source/directives/octets/List.ts

@@ -1,32 +0,0 @@
-import { 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 '../../Directive'
-
-import type { Directive, Input } from './types'
-
-export class List implements Directive {
-  public readonly targeted = false
-
-  private readonly discovery: Promise<Component>
-  private storage: Component | null = null
-
-  public constructor (value: null, discovery: Promise<Component>) {
-    schemas.remove.validate(value)
-
-    this.discovery = discovery
-  }
-
-  public async apply (storage: string, request: Input): Promise<Output> {
-    this.storage ??= await this.discovery
-
-    const input = { storage, path: request.path }
-    const list = await this.storage.invoke<Maybe<unknown>>('list', { input })
-
-    if (list instanceof Error)
-      throw new NotFound()
-
-    return { body: list }
-  }
-}

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 '../../Directive'
-
-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.remove.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.path
-    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,158 +0,0 @@
-import { Readable } from 'node:stream'
-import { posix } from 'node:path'
-import { match } from 'matchacho'
-import { promex } from '@toa.io/generic'
-import { BadRequest, UnsupportedMediaType } from '../../HTTP'
-import * as schemas from './schemas'
-import type { Maybe } from '@toa.io/types'
-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 '../../Directive'
-import type { Directive, Input } from './types'
-
-export class Store implements Directive {
-  public readonly targeted = false
-
-  private readonly accept: string | undefined
-  private readonly workflow: Workflow | undefined
-  private readonly discovery: Record<string, Promise<Component>> = {}
-  private readonly remotes: Remotes
-  private readonly components: Record<string, 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)
-
-    this.workflow = match(options?.workflow,
-      Array, (units: Unit[]) => units,
-      Object, (unit: Unit) => [unit],
-      undefined)
-
-    this.discovery.storage = discovery
-    this.remotes = remotes
-  }
-
-  public async apply (storage: string, request: Input): Promise<Output> {
-    this.storage ??= await this.discovery.storage
-
-    const input = { storage, request, accept: this.accept }
-    const entry = await this.storage.invoke('store', { input })
-
-    return match<Output>(entry,
-      Error, (error: ErrorType) => this.throw(error),
-      () => this.reply(request, storage, entry))
-  }
-
-  private reply (request: Input, storage: string, entry: Entry): Output {
-    const body = this.workflow === undefined
-      ? entry
-      : Readable.from(this.execute(request, storage, entry))
-
-    return { body }
-  }
-
-  private throw (error: ErrorType): never {
-    throw match(error.code,
-      'NOT_ACCEPTABLE', () => new UnsupportedMediaType(),
-      'TYPE_MISMATCH', () => new BadRequest(),
-      error)
-  }
-
-  /* eslint-disable no-useless-return, max-depth */
-
-  /**
-   * Execute workflow units sequentially, steps within a unit in parallel.
-   * Yield results as soon as they come.
-   *
-   * If you need to change this, it may take a while.
-   */
-  private async * execute (request: Input, storage: string, entry: Entry): AsyncGenerator {
-    yield entry
-
-    const path = posix.join(request.path, entry.id)
-    let interrupted = false
-
-    for (const unit of this.workflow as Workflow) {
-      if (interrupted)
-        break
-
-      const steps = Object.keys(unit)
-
-      // unit result promises queue
-      const results = Array.from(steps, promex<unknown>)
-      let next = 0
-
-      // execute steps in parallel
-      for (const step of steps)
-        // these promises are indirectly awaited in the yield loop
-        void (async () => {
-          const endpoint = unit[step]
-          const context: Context = { storage, path, entry }
-          const result = await this.call(endpoint, context)
-
-          if (interrupted)
-            return
-
-          // as a result is received, resolve the next promise from the queue
-          const promise = results[next++]
-
-          if (result instanceof Error) {
-            interrupted = true
-            promise.resolve({ error: { step, ...result } })
-
-            // cancel pending promises
-            results[next].resolve(null)
-          } else
-            promise.resolve({ [step]: result ?? null })
-        })().catch((e) => results[next].reject(e))
-
-      // yield results from the queue as they come
-      for (const promise of results) {
-        const result = await promise
-
-        if (result === null) // canceled promise
-          break
-        else
-          yield result
-      }
-    }
-  }
-
-  private async call (endpoint: string, context: Context): 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: 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]
-  }
-}
-
-type Unit = Record<string, string>
-type Workflow = Unit[]
-
-interface Options {
-  accept: string | string[]
-  workflow: Workflow | Unit
-}
-
-interface Context {
-  storage: string
-  path: string
-  entry: Entry
-}