@toa.io/extensions.exposition 1.0.0-alpha.7 → 1.0.0-alpha.73

package/source/directives/auth/Role.ts

@@ -1,14 +1,18 @@
+import assert from 'node:assert'
 import { type Component, type Query } from '@toa.io/core'
 import { type Directive, type Identity } from './types'
+import type { Parameter } from '../../RTD'
 
 export class Role implements Directive {
   public static remote: Component | null = null
   private readonly roles: string[]
   private readonly discovery: Promise<Component>
+  private readonly dynamic: boolean
 
   public constructor (roles: string | string[], discovery: Promise<Component>) {
     this.roles = typeof roles === 'string' ? [roles] : roles
     this.discovery = discovery
+    this.dynamic = this.roles.some((role) => role.includes('{'))
   }
 
   public static async set (identity: Identity, discovery: Promise<Component>): Promise<void> {
@@ -22,37 +26,41 @@ export class Role implements Directive {
     identity.roles = await this.remote.invoke('list', { query })
   }
 
-  public async authorize (identity: Identity | null): Promise<boolean> {
+  public async authorize
+  (identity: Identity | null, _: unknown, parameters: Parameter[]): Promise<boolean> {
     if (identity === null)
       return false
 
     await Role.set(identity, this.discovery)
 
-    if (identity.roles === undefined)
+    if (identity.roles!.length === 0) // Role.set()
+
       return false
 
-    return this.match(identity.roles)
+    return this.match(identity.roles!, parameters)
   }
 
-  private match (roles: string[]): boolean {
+  private match (roles: string[], parameters: Parameter[]): boolean {
+    const required = this.dynamic ? this.substitute(parameters) : this.roles
+
     for (const role of roles) {
-      const index = this.roles.findIndex((expected) => compare(expected, role))
+      const ok = required.some((expected) => expected === role || expected.startsWith(role + ':'))
 
-      if (index !== -1)
+      if (ok)
         return true
     }
 
     return false
   }
-}
 
-function compare (expected: string, actual: string): boolean {
-  const exp = expected.split(':')
-  const act = actual.split(':')
+  private substitute (parameters: Parameter[]): string[] {
+    return this.roles.map((role) => role.replaceAll(/{(\w+)}/g, (_, key) => {
+      const value = parameters.find((parameter) => parameter.name === key)?.value
 
-  for (let i = 0; i < act.length; i++)
-    if (exp[i] !== act[i])
-      return false
+      assert.ok(value !== undefined,
+        `Role '${role}' requires '${key}' route parameter.`)
 
-  return true
+      return value
+    }))
+  }
 }

package/source/directives/auth/split.ts

@@ -5,7 +5,7 @@ export function split (authorization: string): [Scheme, string] {
   const space = authorization.indexOf(' ')
 
   if (space === -1)
-    throw new http.Unauthorized('Malformed authorization header.')
+    throw new http.Unauthorized('Malformed authorization header')
 
   const Scheme = authorization.slice(0, space)
   const scheme = Scheme.toLowerCase() as Scheme

package/source/directives/auth/types.ts

@@ -8,7 +8,7 @@ export interface Directive {
   authorize: (
     identity: Identity | null,
     input: Input,
-    parameters: Parameter[],
+    parameters: Parameter[]
   ) => boolean | Promise<boolean>
 
   reply?: (identity: Identity | null) => http.OutgoingMessage

package/source/directives/cache/Cache.ts

@@ -1,19 +1,19 @@
 import { Control } from './Control'
 import { Exact } from './Exact'
-import type { Input, Output } from '../../io'
-import type { Directive } from './types'
+import type { Output } from '../../io'
+import type { AuthenticatedContext, Directive } from './types'
 import type { DirectiveFamily } from '../../RTD'
 import type * as http from '../../HTTP'
 
 export class Cache implements DirectiveFamily<Directive> {
   public readonly name: string = 'cache'
-  public readonly mandatory: boolean = false
+  public readonly mandatory: boolean = true
 
   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.`)
+      throw new Error(`Directive 'cache:${name}' is not implemented.`)
 
     return new Class(value)
   }
@@ -23,9 +23,16 @@ export class Cache implements DirectiveFamily<Directive> {
   }
 
   public async settle
-  (directives: Directive[], input: Input, response: http.OutgoingMessage): Promise<void> {
+  (directives: Directive[], context: AuthenticatedContext, response: http.OutgoingMessage): Promise<void> {
+    const directive = directives[0]
+
     response.headers ??= new Headers()
-    directives[0]?.set(input, response.headers)
+
+    if (directive === undefined) {
+      if (context.identity !== null && !Control.disabled(response.headers))
+        response.headers.set('cache-control', 'private')
+    } else
+      directive.set(context, response.headers)
   }
 }
 

package/source/directives/cache/Control.ts

@@ -4,56 +4,82 @@ 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 static 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
+  }
+
   public set (context: AuthenticatedContext, headers: Headers): void {
     if (!['GET', 'HEAD', 'OPTIONS'].includes(context.request.method))
       return
 
     this.cache ??= this.resolve(context)
 
+    if (Control.disabled(headers))
+      return
+
     headers.set('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 = this.mask()
+    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)
+    if ((directives & (PUBLIC | PRIVATE)) === 0) {
+      this.vary = true
+
       return 'private, ' + this.value
+    }
 
     return this.value
   }
+}
 
-  private mask (): number {
-    const directives = this.value.match(DIRECTIVES_RX)
+function mask (value: string): number {
+  const directives = value.match(DIRECTIVES_RX)
 
-    if (directives === null)
-      return 0
+  if (directives === null)
+    return 0
 
-    let mask = 0
+  let mask = 0
 
-    for (const directive of directives)
-      mask |= match<number>(directive,
-        'private', PRIVATE,
-        'public', PUBLIC,
-        'no-cache', NO_CACHE,
-        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
-  }
+  return mask
 }
 
-const DIRECTIVES_RX = /\b(private|public|no-cache)\b/ig
+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/cors/CORS.ts

@@ -14,7 +14,7 @@ export class CORS implements Interceptor {
   ])
 
   private readonly headers = new Headers({
-    'access-control-allow-methods': 'GET, POST, PUT, PATCH, DELETE',
+    'access-control-allow-methods': 'GET, POST, PUT, PATCH, DELETE, LOCK, UNLOCK',
     'access-control-allow-credentials': 'true',
     'access-control-allow-headers': Array.from(this.requestHeaders).join(', '),
     'access-control-max-age': '3600',

package/source/directives/dev/Development.ts

@@ -12,7 +12,7 @@ export class Development implements DirectiveFamily<Directive> {
     const Class = constructors[name]
 
     if (Class === undefined)
-      throw new Error(`Directive '${name}' is not provided by the '${this.name}' family.`)
+      throw new Error(`Directive 'dev:${name}' is not implemented.`)
 
     return new Class(value)
   }

package/source/directives/flow/Fetch.ts

@@ -0,0 +1,88 @@
+import { Readable } from 'node:stream'
+import assert from 'node:assert'
+import { match } from 'matchacho'
+import { NotFound } from '../../HTTP'
+import type { Directive } from './types'
+import type { ReadableStream } from 'node:stream/web'
+import type { Remotes } from '../../Remotes'
+import type { Maybe } from '@toa.io/types'
+import type { Component } from '@toa.io/core'
+import type { Output } from '../../io'
+import type { Input } from '../octets/types'
+import type { Parameter } from '../../RTD'
+
+export class Fetch implements Directive {
+  public readonly targeted = true
+
+  private readonly connecting: Promise<Component>
+  private remote: Component | null = null
+  private readonly operation: string
+
+  public constructor (endpoint: string, discovery: Remotes) {
+    assert.equal(typeof endpoint, 'string', '`flow:redirect` must be a string')
+
+    const [operation, name, namespace = 'default'] = endpoint.split('.').reverse()
+
+    this.operation = operation
+    this.connecting = discovery.discover(namespace, name)
+  }
+
+  public async apply (input: Input, parameters: Parameter[]): Promise<Output> {
+    if ('if-none-match' in input.request.headers)
+      return { status: 304 }
+
+    this.remote ??= await this.connecting
+
+    const request = await this.remote.invoke<Maybe<Request | string>>(this.operation, {
+      input: {
+        authority: input.authority,
+        path: input.request.url,
+        parameters: Object.fromEntries(parameters.map(({ name, value }) => [name, value]))
+      }
+    })
+
+    if (request instanceof Error)
+      throw new NotFound(request)
+
+    const { url, options } = match<Request>(request,
+      String, { url: request },
+      (request: Request): Request => ({
+        url: request.url,
+        options: {
+          method: request.options?.method ?? 'GET',
+          body: request.options?.body,
+          headers: request.options?.headers
+        }
+      }))
+
+    const response = await fetch(url, options)
+
+    if (!response.ok)
+      throw new NotFound()
+
+    const headers = new Headers()
+
+    for (const header of ['content-type', 'content-length', 'etag']) {
+      const value = response.headers.get(header)
+
+      if (value !== null)
+        headers.set(header, value)
+    }
+
+    return {
+      headers,
+      body: response.body === null ? null : Readable.fromWeb(response.body as ReadableStream)
+    }
+  }
+}
+
+interface Request {
+  url: string
+  options?: RequestOptions
+}
+
+interface RequestOptions {
+  method?: string
+  body?: string
+  headers?: Record<string, string>
+}

package/source/directives/flow/Flow.ts

@@ -0,0 +1,34 @@
+import { Fetch } from './Fetch'
+import type { Directive } from './types'
+import type { Input, Output } from '../../io'
+import type { DirectiveFamily, Parameter } from '../../RTD'
+import type { Remotes } from '../../Remotes'
+
+export class Flow implements DirectiveFamily<Directive> {
+  public readonly name: string = 'flow'
+  public readonly mandatory: boolean = false
+
+  public create (name: string, value: unknown, remotes: Remotes): Directive {
+    const Class = constructors[name]
+
+    if (Class === undefined)
+      throw new Error(`Directive '${this.name}:${name}' is not implemented.`)
+
+    return new Class(value, remotes)
+  }
+
+  public async preflight (directives: Directive[], input: Input, parameters: Parameter[]): Promise<Output> {
+    for (const directive of directives) {
+      const output = await directive.apply(input, parameters)
+
+      if (output !== null)
+        return output
+    }
+
+    return null
+  }
+}
+
+const constructors: Record<string, new (value: any, discovery: Remotes) => Directive> = {
+  fetch: Fetch
+}

package/source/directives/flow/index.ts

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

package/source/directives/flow/types.ts

@@ -0,0 +1,6 @@
+import type { Input, Output } from '../../io'
+import type { Parameter } from '../../RTD'
+
+export interface Directive {
+  apply: (input: Input, parameters: Parameter[]) => Promise<Output>
+}

package/source/directives/index.ts

@@ -5,8 +5,10 @@ import { dev } from './dev'
 import { octets } from './octets'
 import { io } from './io'
 import { vary } from './vary'
+import { req } from './require'
+import { flow } from './flow'
 import type { DirectiveFamily } from '../RTD'
 import type { Interceptor } from '../Interception'
 
-export const families: DirectiveFamily[] = [authorization, io, cache, vary, octets, dev]
+export const families: DirectiveFamily[] = [authorization, io, cache, vary, req, flow, octets, dev]
 export const interceptors: Interceptor[] = [cors]

package/source/directives/io/Input.ts

@@ -12,7 +12,7 @@ export class Input implements Directive {
   }
 
   public static validate (permissions: unknown): asserts permissions is Permissions {
-    schemas.input.validate(permissions, 'Incorrect \'io:input\' format')
+    schemas.input.validate<Permissions>(permissions, 'Incorrect \'io:input\' format')
   }
 
   public attach (context: Context): void {
@@ -21,15 +21,15 @@ export class Input implements Directive {
 
   private check (body: unknown): unknown {
     try {
-      schemas.message.validate(body)
+      schemas.message.validate<Message | Message[]>(body)
     } catch {
-      throw new BadRequest('Invalid request body.')
+      throw new BadRequest('Invalid request body')
     }
 
     const property = this.violation(body)
 
     if (property !== undefined)
-      throw new BadRequest(`Unexpected input: ${property}.`)
+      throw new BadRequest(`Unexpected input: ${property}`)
 
     return body
   }

package/source/directives/io/Output.ts

@@ -1,4 +1,5 @@
 import { Stream } from 'node:stream'
+import { console } from 'openspan'
 import * as schemas from './schemas'
 import type { Message } from './Message'
 import type { Directive } from './Directive'
@@ -40,15 +41,15 @@ export class Output implements Directive {
 
       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.`)
+          console.warn('Permissions for \'io:output\' are not specified properly. Response omitted.',
+            { path: context.url.pathname })
 
         delete message.body
 
         return
       }
 
-      schemas.message.validate(message.body,
+      schemas.message.validate<Message>(message.body,
         '\'io:output\' expects response to be an object or array of objects')
 
       if (Array.isArray(message.body))

package/source/directives/octets/Context.ts

@@ -1,4 +1,4 @@
-import * as schemas from './schemas'
+import assert from 'node:assert'
 import { Directive } from './Directive'
 import type { Output } from '../../io'
 
@@ -8,7 +8,8 @@ export class Context extends Directive {
 
   public constructor (value: unknown) {
     super()
-    schemas.context.validate(value)
+
+    assert.ok(typeof value === 'string', 'Directive \'octets:context\' must must be a string')
 
     this.storage = value
   }

package/source/directives/octets/Fetch.ts

@@ -2,9 +2,9 @@ import { posix } from 'node:path'
 import { Forbidden, NotFound } from '../../HTTP'
 import * as schemas from './schemas'
 import { Directive } from './Directive'
+import type { Readable } from 'node:stream'
 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'
@@ -12,19 +12,20 @@ import type { Input } from './types'
 export class Fetch extends Directive {
   public readonly targeted = true
 
-  private readonly permissions: Required<Permissions> = {
+  private readonly options: Required<Options> = {
     blob: true,
     meta: false
   }
 
   private readonly discovery: Promise<Component>
-  private storage: Component = null as unknown as Component
+  private storage!: Component
 
-  public constructor (permissions: Permissions | null, discovery: Promise<Component>) {
+  public constructor (options: Options | null, discovery: Promise<Component>) {
     super()
-    schemas.fetch.validate(permissions)
 
-    Object.assign(this.permissions, permissions)
+    schemas.fetch.validate(options)
+    Object.assign(this.options, options)
+
     this.discovery = discovery
   }
 
@@ -35,12 +36,12 @@ export class Fetch extends Directive {
     const metadata = input.subtype === 'octets.entry'
 
     if (!variant && metadata)
-      if (this.permissions.meta)
+      if (this.options.meta)
         return this.get(storage, input)
       else
         throw new Forbidden('Metadata is not accessible.')
 
-    if (!variant && !this.permissions.blob)
+    if (!variant && !this.options.blob)
       throw new Forbidden('BLOB variant must be specified.')
 
     return await this.fetch(storage, input)
@@ -63,7 +64,7 @@ export class Fetch extends Directive {
     const headers = new Headers({
       'content-type': result.type,
       'content-length': result.size.toString(),
-      etag: result.checksum
+      etag: `"${result.checksum}"`
     })
 
     return {
@@ -87,7 +88,7 @@ export class Fetch extends Directive {
   }
 }
 
-export interface Permissions {
+export interface Options {
   blob?: boolean
   meta?: boolean
 }

package/source/directives/octets/List.ts

@@ -12,15 +12,15 @@ import type { Input } from './types'
 export class List extends Directive {
   public readonly targeted = false
 
-  private readonly permissions: Required<Permissions> = { meta: false }
+  private readonly options: Required<Options> = { meta: false }
   private readonly discovery: Promise<Component>
   private storage: Component | null = null
 
-  public constructor (permissions: Permissions | null, discovery: Promise<Component>) {
+  public constructor (permissions: Options | null, discovery: Promise<Component>) {
     super()
     schemas.list.validate(permissions)
 
-    Object.assign(this.permissions, permissions)
+    Object.assign(this.options, permissions)
     this.discovery = discovery
   }
 
@@ -29,7 +29,7 @@ export class List extends Directive {
 
     const metadata = input.subtype === 'octets.entries'
 
-    if (metadata && !this.permissions.meta)
+    if (metadata && !this.options.meta)
       throw new Forbidden('Metadata is not accessible.')
 
     const list = await this.storage.invoke<Maybe<string[]>>('list', {
@@ -67,6 +67,6 @@ export class List extends Directive {
   }
 }
 
-export interface Permissions {
+export interface Options {
   meta?: boolean
 }

package/source/directives/octets/Octets.ts

@@ -4,7 +4,6 @@ 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 { Directive } from './Directive'
 import type { Output } from '../../io'
@@ -23,7 +22,7 @@ export class Octets implements DirectiveFamily<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')
 
@@ -66,7 +65,6 @@ const DIRECTIVES: Record<string, Constructor> = {
   fetch: Fetch,
   list: List,
   delete: Delete,
-  permute: Permute,
   workflow: WorkflowDirective
 }