@toa.io/extensions.exposition 1.0.0-alpha.9 → 1.0.0-alpha.91

package/source/deployment.ts

@@ -1,3 +1,4 @@
+import assert from 'node:assert'
 import { type Dependency, type Service } from '@toa.io/operations'
 import { encode } from '@toa.io/generic'
 import { type Annotation } from './Annotation'
@@ -5,50 +6,59 @@ import * as schemas from './schemas'
 import { shortcuts } from './Directive'
 import { components } from './Composition'
 import { parse } from './RTD/syntax'
+import { DELAY, PORT } from './HTTP'
+
+export function deployment (_: unknown, annotation?: Annotation): Dependency {
+  assert.ok(annotation !== undefined, 'Exposition context annotation is required')
+  schemas.annotation.validate(annotation)
 
-export function deployment (_: unknown, annotation: Annotation | undefined): Dependency {
   const labels = components().labels
 
   const service: Service = {
     group: 'exposition',
     name: 'gateway',
-    port: 8000,
+    port: PORT,
     // eslint-disable-next-line @typescript-eslint/no-var-requires
     version: require('../package.json').version,
     variables: [],
-    components: labels
-  }
-
-  if (annotation?.host !== undefined)
-    service.ingress = {
-      host: annotation.host,
-      class: annotation.class,
-      annotations: annotation.annotations
+    components: labels,
+    ingress: { default: true, hosts: [] },
+    probe: {
+      path: '/.ready',
+      port: PORT,
+      delay: DELAY
     }
+  }
 
   if (annotation?.['/'] !== undefined) {
     const tree = parse(annotation['/'], shortcuts)
 
-    service.variables.push({
+    service.variables!.push({
       name: 'TOA_EXPOSITION',
       value: encode(tree)
     })
   }
 
-  if (annotation?.debug === true)
-    service.variables.push({
-      name: 'TOA_EXPOSITION_DEBUG',
-      value: '1'
-    })
+  const { debug, trace, authorities } = annotation
 
-  if (annotation?.trace === true)
-    service.variables.push({
-      name: 'TOA_EXPOSITION_TRACE',
-      value: '1'
-    })
+  service.ingress!.hosts = Object.values(authorities)
+  service.ingress!.class = annotation.class
+  service.ingress!.annotations = annotation.annotations
+
+  const properties: Properties = { authorities }
+
+  if (debug === true)
+    properties.debug = true
 
-  if (annotation !== undefined)
-    schemas.annotaion.validate(annotation)
+  if (trace === true)
+    properties.trace = true
+
+  service.variables!.push({
+    name: 'TOA_EXPOSITION_PROPERTIES',
+    value: encode(properties)
+  })
 
   return { services: [service] }
 }
+
+type Properties = Pick<Annotation, 'authorities' | 'debug' | 'trace'>

package/source/directives/auth/Authorization.ts

@@ -7,8 +7,10 @@ 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 { Delegate } from './Delegate'
+import { Federation } from './Federation'
+import { split } from './split'
 import { PRIMARY, PROVIDERS } from './schemes'
 import type { Output } from '../../io'
 import type { Component } from '@toa.io/core'
@@ -38,7 +40,7 @@ export class Authorization implements DirectiveFamily<Directive, Extension> {
 
   public create (name: string, value: any, remotes: Remotes): Directive {
     assert.ok(name in constructors,
-      `Directive '${name}' is not provided by the '${this.name}' family.`)
+      `Directive 'auth:${name}' is not implemented`)
 
     const Class = constructors[name]
 
@@ -49,69 +51,88 @@ export class Authorization implements DirectiveFamily<Directive, Extension> {
       Role, () => new Role(value as string | string[], this.discovery.roles),
       Rule, () => new Rule(value as Record<string, string>, this.create.bind(this)),
       Incept, () => new Incept(value as string, this.discovery),
+      Delegate, () => new Delegate(value as string, this.discovery.roles),
       () => new Class(value))
   }
 
   public async preflight (directives: Directive[],
     input: Input,
     parameters: Parameter[]): Promise<Output> {
-    const identity = await this.resolve(input.request.headers.authorization)
+    /**
+     * Some authentication scheme providers may create identity during authentication;
+     * therefore, we need to skip the authentication process if the Incept directive is present.
+     *
+     * If the provided credentials already exist,
+     * the inception will cause a unique constraint violation on the settle stage.
+     */
+    const inception = directives.reduce((yes, directive) => yes || directive instanceof Incept, false)
 
-    input.identity = identity
+    input.identity = inception ? null : await this.resolve(input.authority, input.request.headers.authorization)
 
     for (const directive of directives) {
-      const allow = await directive.authorize(identity, input, parameters)
+      const allow = await directive.authorize(input.identity, input, parameters)
 
       if (allow)
-        return directive.reply?.(identity) ?? null
+        return directive.reply?.(input.identity) ?? null
     }
 
-    if (identity === null)
+    if (input.identity === null)
       throw new http.Unauthorized()
     else
       throw new http.Forbidden()
   }
 
   public async settle (directives: Directive[],
-    request: Input,
+    input: Input,
     response: http.OutgoingMessage): Promise<void> {
-    for (const directive of directives) await directive.settle?.(request, response)
+    await Promise.all(directives.map(async (directive) =>
+      directive.settle?.(input, response)))
 
-    const identity = request.identity
+    const identity = input.identity
 
-    if (identity === null) return
+    if (identity === null)
+      return
 
-    if (identity.scheme === PRIMARY && !identity.refresh) 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)
+    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}`
+    const token = await this.tokens.invoke<string>('encrypt', {
+      input: { authority: input.authority, identity }
+    })
 
-    if (response.headers === undefined) response.headers = new Headers()
+    const authorization = `Token ${token}`
 
+    response.headers ??= new Headers()
     response.headers.set('authorization', authorization)
   }
 
-  private async resolve (authorization: string | undefined): Promise<Identity | null> {
-    if (authorization === undefined) return null
+  private async resolve (authority: string, 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}'.`)
+      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
+      input: {
+        authority,
+        credentials
+      }
     })
 
-    if (result instanceof Error) return null
+    if (result instanceof Error)
+      return null
 
     const identity = result.identity
 
@@ -139,7 +160,9 @@ const constructors: Record<string, new (value: any, argument?: any) => Directive
   rule: Rule,
   incept: Incept,
   scheme: Scheme,
-  echo: Echo
+  echo: Echo,
+  delegate: Delegate,
+  claim: Federation
 }
 
 const REMOTES: Remote[] = ['basic', 'federation', 'tokens', 'roles', 'bans']

package/source/directives/auth/Delegate.ts

@@ -0,0 +1,42 @@
+import { BadRequest } from '../../HTTP'
+import { type Directive, type Identity } from './types'
+import { Role } from './Role'
+import type { Component } from '@toa.io/core'
+import type { Input } from '../../io'
+
+export class Delegate implements Directive {
+  private readonly property: string
+  private readonly discovery: Promise<Component>
+
+  public constructor (property: string, discovery: Promise<Component>) {
+    this.property = property
+    this.discovery = discovery
+  }
+
+  public async authorize (identity: Identity | null, context: Input): Promise<boolean> {
+    if (identity === null)
+      return false
+
+    if (identity.roles === undefined)
+      await Role.set(identity, this.discovery)
+
+    context.pipelines.body.push((body) => this.embed(body, identity))
+
+    return true
+  }
+
+  private embed (body: unknown, identity: Identity): Record<string, unknown> {
+    if (body === undefined)
+      body = {}
+
+    check(body)
+    body[this.property] = structuredClone(identity)
+
+    return body
+  }
+}
+
+function check (body: unknown): asserts body is Record<string, unknown> {
+  if (typeof body !== 'object' || body === null)
+    throw new BadRequest('Invalid request body')
+}

package/source/directives/auth/Echo.ts

@@ -1,12 +1,26 @@
-import { type OutgoingMessage } from '../../HTTP'
-import { type Directive, type Identity } from './types'
+import { newid } from '@toa.io/generic'
+import type { OutgoingMessage } from '../../HTTP'
+import type { Directive, Identity, Input } from './types'
 
 export class Echo implements Directive {
-  public authorize (identity: Identity | null): boolean {
-    return identity !== null
+  public authorize (identity: Identity | null, input: Input): boolean {
+    if (identity === null && 'authorization' in input.request.headers)
+      return false
+
+    input.identity ??= this.create()
+
+    return true
   }
 
   public reply (identity: Identity | null): OutgoingMessage {
-    return { body: identity }
+    const body = identity!
+
+    return body.scheme === null
+      ? { status: 201, body }
+      : { body }
+  }
+
+  private create (): Identity {
+    return { id: newid(), scheme: null, refresh: false, roles: [] }
   }
 }

package/source/directives/auth/Federation.ts

@@ -0,0 +1,84 @@
+import assert from 'node:assert'
+import type { Directive, Identity, Input } from './types'
+import type { Parameter } from '../../RTD'
+
+export class Federation implements Directive {
+  private readonly matchers: Array<[keyof Claim, Matcher]>
+
+  public constructor (options: Options) {
+    this.matchers = (Object.entries(options) as Array<[keyof Claim, string]>)
+      .map(([key, value]) => [key, toMatcher(value)])
+
+    assert.ok(this.matchers.length > 0, 'auth:claim requires at least one property defined')
+  }
+
+  public authorize (identity: Identity | null, context: Input, parameters: Parameter[]): boolean {
+    if (identity === null || !('claim' in identity))
+      return false
+
+    const claim = (identity as FederatedIdentity).claim
+
+    for (const [key, match] of this.matchers)
+      if (!match(claim[key], context, parameters))
+        return false
+
+    return true
+  }
+}
+
+function toMatcher (expression: string): Matcher {
+  if (expression.startsWith(':')) {
+    const key = expression.slice(1) as 'authority'
+
+    if (key === 'authority')
+      return (value, context) => matches(value, context[key])
+
+    if (key === 'domain')
+      return (value, context) => {
+        return Array.isArray(value)
+          ? value.some((iss) => codomain(iss, context))
+          : codomain(value, context)
+      }
+
+    throw new Error(`Unknown 'auth:claim' syntax: ${expression}`)
+  }
+
+  if (expression.startsWith('/:')) {
+    const name = expression.slice(2)
+
+    return (value, _, parameters) => parameters
+      .some((parameter) => parameter.name === name && matches(value, parameter.value))
+  }
+
+  return (value) => matches(value, expression)
+}
+
+function matches (value: string | string[], reference: string): boolean {
+  return Array.isArray(value)
+    ? value.includes(reference)
+    : value === reference
+}
+
+function codomain (iss: string, context: Input): boolean {
+  const hostname = new URL(iss).hostname
+  const dot = hostname.indexOf('.')
+  const basename = dot === -1 ? hostname : hostname.slice(dot)
+
+  return context.authority.slice(-basename.length) === basename
+}
+
+type Matcher = (value: string | string[], context: Input, parameters: Parameter[]) => boolean
+
+interface Claim {
+  iss: string
+  sub: string
+  aud: string | string[]
+}
+
+interface Options extends Partial<Claim> {
+  iss: string
+}
+
+interface FederatedIdentity extends Identity {
+  claim: Claim
+}

package/source/directives/auth/Incept.ts

@@ -23,7 +23,7 @@ export class Incept implements Directive {
 
     if (id === undefined)
       throw new http.Conflict('Identity inception has failed as the response body ' +
-        ` does not contain the '${this.property}' property.`)
+        `does not contain the '${this.property}' property`)
 
     const [scheme, credentials] = split(input.request.headers.authorization!)
     const provider = PROVIDERS[scheme]
@@ -31,15 +31,16 @@ export class Incept implements Directive {
     this.schemes[scheme] ??= await this.discovery[provider]
 
     const identity = await this.schemes[scheme]
-      .invoke<Maybe<Identity>>('create', {
+      .invoke<Maybe<Identity>>('incept', {
       input: {
+        authority: input.authority,
         id,
         credentials
       }
     })
 
     if (identity instanceof Error)
-      throw new http.Conflict(identity)
+      throw new http.UnprocessableEntity(identity)
 
     input.identity = identity
     input.identity.scheme = scheme

package/source/directives/auth/Role.test.ts

@@ -2,6 +2,7 @@ import { type Component } from '@toa.io/core'
 import { generate } from 'randomstring'
 import { Role } from './Role'
 import { type Identity } from './types'
+import type { Parameter } from '../../RTD'
 
 const remote = {
   invoke: jest.fn()
@@ -16,16 +17,26 @@ beforeEach(() => {
 it('should return false if not matched', async () => {
   const roles = ['admin', 'user']
   const directive = new Role(roles, discovery)
-  const identity: Identity = { id: generate(), scheme: '', refresh: false }
+
+  const identity: Identity = {
+    id: generate(),
+    scheme: '',
+    refresh: false
+  }
 
   remote.invoke.mockResolvedValueOnce(['guest'])
 
-  const result = await directive.authorize(identity)
+  const result = await directive.authorize(identity, undefined, [])
 
   expect(result).toBe(false)
 
   expect(remote.invoke)
-    .toBeCalledWith('list', { query: { criteria: `identity==${identity.id}`, limit: 1024 } })
+    .toBeCalledWith('list', {
+      query: {
+        criteria: `identity==${identity.id}`,
+        limit: 1024
+      }
+    })
 })
 
 it('should return true on exact match', async () => {
@@ -52,11 +63,47 @@ it('should return false on non-scope substring match', async () => {
   expect(result).toBe(false)
 })
 
-async function match (expected: string[], actual: string[]): Promise<boolean> {
+it('should return true on match with parameters', async () => {
+  const result = await match(['app:{org}:reviews'],
+    ['app:29e54ae1:reviews'], [{
+      name: 'org',
+      value: '29e54ae1'
+    }])
+
+  expect(result).toBe(true)
+})
+
+it('should return true on match with parameters', async () => {
+  const result = await match(['app:{org}:reviews'],
+    ['app:29e54ae1:reviews'], [{
+      name: 'org',
+      value: '29e54ae1'
+    }])
+
+  expect(result).toBe(true)
+})
+
+it('should return false on mismatch with parameters', async () => {
+  const result = await match(['app:{org}:reviews'],
+    ['app:29e54ae1:reviews'], [{
+      name: 'org',
+      value: '88584c9b'
+    }])
+
+  expect(result).toBe(false)
+})
+
+async function match
+(expected: string[], actual: string[], parameters: Parameter[] = []): Promise<boolean> {
   const directive = new Role(expected, discovery)
-  const identity: Identity = { id: generate(), scheme: '', refresh: false }
+
+  const identity: Identity = {
+    id: generate(),
+    scheme: '',
+    refresh: false
+  }
 
   remote.invoke.mockResolvedValueOnce(actual)
 
-  return await directive.authorize(identity)
+  return await directive.authorize(identity, undefined, parameters)
 }

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/Scheme.ts

@@ -19,7 +19,7 @@ export class Scheme implements Directive {
 
     if (scheme !== this.scheme)
       throw new http.Forbidden(this.Scheme +
-        ' authentication scheme is required to access this resource.')
+        ' authentication scheme is required to access this resource')
 
     return false
   }

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
@@ -18,7 +18,7 @@ export interface Directive {
 
 export interface Identity {
   readonly id: string
-  scheme: string
+  scheme: string | null // null for transient identities
   roles?: string[]
   refresh: boolean
 }

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)
   }
 }