@toa.io/extensions.exposition 1.0.0-alpha.15 → 1.0.0-alpha.150

package/components/identity.federation/source/types.ts

@@ -1,56 +0,0 @@
-import { type Call, type Observation, type Query } from '@toa.io/types'
-import type { Schemas } from './schemas'
-
-export interface Context {
-  local: {
-    observe: Observation<Entity & { id: string }>
-    transit: Call<TransitOutput, TransitInput>
-  }
-  remote: {
-    identity: {
-      tokens: {
-        revoke: Call<void, IdentityTokensRevokeInput>
-      }
-    }
-  }
-  configuration: Required<Schemas>['configuration']
-}
-
-export type Entity = Required<Schemas>['entity']
-
-export interface TransitInput {
-  readonly iss: string
-  readonly sub: string
-}
-
-export interface TransitOutput {
-  id: string
-}
-
-interface IdentityTokensRevokeInput {
-  query: Query
-}
-
-export interface JwtHeader {
-  typ?: string
-  alg: string
-  kid?: string
-}
-
-/**
- * @see {@link https://openid.net/specs/openid-connect-core-1_0.html#IDToken}
- */
-export interface IdToken {
-  iss: string
-  sub: string
-  aud: string
-  exp: number
-  iat: number
-  nbf?: number
-}
-
-export interface AuthenticateOutput {
-  identity: {
-    id: string
-  }
-}

package/components/identity.tokens/operations/types.d.ts

@@ -1,39 +0,0 @@
-import { type Call, type Maybe, type Observation } from '@toa.io/types';
-export interface Context {
-    local: {
-        observe: Observation<Entity>;
-        decrypt: Call<Maybe<DecryptOutput>, string>;
-    };
-    configuration: Configuration;
-}
-export interface Configuration {
-    readonly key0: string;
-    readonly key1?: string;
-    readonly lifetime: number;
-    readonly refresh: number;
-}
-export interface Entity {
-    revokedAt?: number;
-}
-export interface Identity extends Record<string, any> {
-    id: string;
-}
-export interface AuthenticateOutput {
-    identity: Identity;
-    refresh: boolean;
-}
-export interface EncryptInput {
-    identity: Identity;
-    lifetime?: number;
-}
-export interface DecryptOutput {
-    identity: Identity;
-    iat: string;
-    exp?: string;
-    refresh: boolean;
-}
-export interface Claim {
-    identity: Identity;
-    iat: string;
-    exp?: string;
-}

package/components/identity.tokens/operations/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../source/types.ts"],"names":[],"mappings":""}

package/components/identity.tokens/source/types.ts

@@ -1,47 +0,0 @@
-import { type Call, type Maybe, type Observation } from '@toa.io/types'
-
-export interface Context {
-  local: {
-    observe: Observation<Entity>
-    decrypt: Call<Maybe<DecryptOutput>, string>
-  }
-  configuration: Configuration
-}
-
-export interface Configuration {
-  readonly key0: string
-  readonly key1?: string
-  readonly lifetime: number
-  readonly refresh: number
-}
-
-export interface Entity {
-  revokedAt?: number
-}
-
-export interface Identity extends Record<string, any> {
-  id: string
-}
-
-export interface AuthenticateOutput {
-  identity: Identity
-  refresh: boolean
-}
-
-export interface EncryptInput {
-  identity: Identity
-  lifetime?: number
-}
-
-export interface DecryptOutput {
-  identity: Identity
-  iat: string
-  exp?: string
-  refresh: boolean
-}
-
-export interface Claim {
-  identity: Identity
-  iat: string
-  exp?: string
-}

package/components/octets.storage/operations/fetch.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const { posix } = require('node:path')
-const { Err } = require('error-value')
-
-async function fetch (input, context) {
-  const storage = context.storages[input.storage]
-  const basename = posix.basename(input.path)
-  const path = posix.dirname(input.path)
-  const [id, suffix] = split(basename)
-  const entry = await storage.get(posix.join(path, id))
-
-  if (entry instanceof Error)
-    return entry
-
-  let variant
-
-  if (suffix !== undefined) {
-    variant = entry.variants.find((variant) => variant.name === suffix)
-
-    if (variant === undefined)
-      return NOT_FOUND
-  }
-
-  const stream = await storage.fetch(input.path)
-
-  if (stream instanceof Error)
-    return stream
-
-  const { type, size } = variant ?? entry
-
-  return { stream, checksum: entry.id, type, size }
-}
-
-function split (basename) {
-  const dot = basename.indexOf('.')
-
-  if (dot === -1)
-    return [basename, undefined]
-  else
-    return [basename.slice(0, dot), basename.slice(dot + 1)]
-}
-
-const NOT_FOUND = Err('NOT_FOUND')
-
-exports.effect = fetch

package/components/octets.storage/operations/list.js

@@ -1,7 +0,0 @@
-'use strict'
-
-function list (input, context) {
-  return context.storages[input.storage].list(input.path)
-}
-
-exports.effect = list

package/components/octets.storage/operations/permute.js

@@ -1,7 +0,0 @@
-'use strict'
-
-function permute (input, context) {
-  return context.storages[input.storage].permute(input.path, input.list)
-}
-
-exports.effect = permute

package/components/octets.storage/operations/store.js

@@ -1,11 +0,0 @@
-'use strict'
-
-function store (input, context) {
-  const { storage, request, accept, meta } = input
-  const path = request.url
-  const claim = request.headers['content-type']
-
-  return context.storages[storage].put(path, request, { claim, accept, meta })
-}
-
-exports.effect = store

package/documentation/vary.md

@@ -1,75 +0,0 @@
-# HTTP request details
-
-The `vary` directives family provides the capability to include HTTP request details as input for an
-operation call.
-
-## TL;DR
-
-```yaml
-exposition:
-  realms:
-    toa: the.toa.io
-  /:group:
-    vary:languages: [en, fr]
-    GET:
-      vary:embed:
-        lang: language # predefined embeddings
-        realm: realm
-        token: :x-access-token # raw header value
-        group: /:group # route parameter
-      endpoint: dummies.get
-```
-
-## Embeddings
-
-Request parts are embedded into the operation call according to the mapping
-defined by the `vary:embed` directive.
-The keys in the embedding map are the names of the input properties details to be embedded to,
-and the values are the names of the embedding functions.
-If the value is an array, the first non-empty embedding function's result is used.
-
-> If a property is already present in the input, the embedded value will overwrite its current
-> value.
-
-### Realm
-
-Realm is an identifier of a domain used to access the Exposition.
-The list of domains is defined by the `vary:realms` directive,
-which is a map of realm names to their domain names.
-
-The `realm` embedding substitutes the realm identified based on the `host` request header.
-
-### Language
-
-The `language` embedding substitutes the most matching language code based on the `accept-language`
-request header and a list of supported languages defined by the `vary:languages` directive, and also
-adds `accept-language` to the `vary` HTTP response header value.
-If neither of the supported languages matches, the first supported language is used.
-
-### Raw header values
-
-Values in the embedding map starting with a semicolon (:) are the names of HTTP request headers
-whose values to be embedded into an operation call.
-The names of these headers are then included in the `vary` HTTP response header
-and [Access-Control-Allow-Headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers)
-of the [CORS](protocol.md#cors).
-
-[Multiple header fields](https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2) are embedded
-as a comma-separated list.
-
-### Route parameters
-
-Values in the embedding map starting with `/:` are the names of route parameters whose values
-to be embedded into an operation call.
-
-### Fallbacks
-
-If the embedding function is an array, the first non-empty resolved value is used.
-
-```yaml
-vary:embed:
-  ip: # fallbacks
-    - :CloudFront-Viewer-Address
-    - :CF-Connecting-IP
-    - :X-Appengine-User-IP
-```

package/features/steps/IdP.ts

@@ -1,154 +0,0 @@
-import { once } from 'node:events'
-import * as crypto from 'node:crypto'
-import * as http from 'node:http'
-import * as assert from 'node:assert'
-import * as util from 'node:util'
-import { binding, given, afterAll } from 'cucumber-tsflow'
-import { Captures } from './Captures'
-
-import type { AddressInfo } from 'node:net'
-
-@binding([Captures])
-export class IdP {
-  private static server?: http.Server
-  private static privateKey?: crypto.KeyObject
-  private static issuer?: string
-
-  public constructor (private readonly captures: Captures) {
-  }
-
-  @afterAll()
-  public static async stop (): Promise<void> {
-    if (this.server instanceof http.Server) {
-      this.server.close()
-      await once(this.server, 'close')
-    }
-  }
-
-  @given(/local IDP is running/i)
-  public async start (): Promise<void> {
-    if (IdP.server instanceof http.Server) return
-
-    // creating the key
-    const {
-      publicKey,
-      privateKey
-    } = await util.promisify(crypto.generateKeyPair)('rsa', {
-      modulusLength: 2048
-    })
-
-    IdP.privateKey = privateKey
-
-    const jwk = JSON.stringify({
-      keys: [{
-        use: 'sig',
-        alg: 'RS256',
-        ...publicKey.export({ format: 'jwk' })
-      }]
-    })
-
-    const JWK_URL = '/.well-known/jwks'
-
-    const server = http.createServer((request, response) => {
-      switch (request.url) {
-        case JWK_URL:
-          response.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Content-Length': jwk.length,
-            'Cache-Control': 'no-cache, no-store, must-revalidate',
-            Pragma: 'no-cache',
-            Expires: '0'
-          })
-          response.end(jwk)
-          break
-
-        case '/.well-known/openid-configuration': {
-          const openIdConfiguration = JSON.stringify({
-            issuer: IdP.issuer,
-            jwks_uri: IdP.issuer + JWK_URL,
-            response_types_supported: ['id_token'],
-            subject_types_supported: ['public'],
-            id_token_signing_alg_values_supported: ['RS256'],
-            scopes_supported: ['openid']
-          })
-
-          response.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Cache-Control': 'public, max-age=3600',
-            'Content-Length': openIdConfiguration.length
-          })
-          response.end(openIdConfiguration)
-        }
-
-          break
-
-        default:
-          response.writeHead(404, 'Not found')
-          response.end()
-      }
-    })
-
-    server.listen(44444, 'localhost')
-    await once(server, 'listening')
-
-    const address = server.address() as AddressInfo
-
-    console.log('IdP is listening on %s:%s', address.address, address.port)
-    IdP.server = server
-    IdP.issuer = `http://localhost:${address.port}`
-  }
-
-  @given('the IDP token for {word} is issued')
-  public async issueToken (user: string): Promise<void> {
-    assert.ok(IdP.privateKey, 'IdP private key is not available')
-
-    const jwt = [
-      {
-        typ: 'JWT',
-        alg: 'RS256'
-      },
-      {
-        iss: IdP.issuer,
-        sub: `${user}-mock-id`,
-        aud: 'test',
-        iat: Math.floor(Date.now() / 1000),
-        exp: Math.floor((Date.now() + 1000 * 60 * 5) / 1000)
-      }
-    ]
-      .map((v) => Buffer.from(JSON.stringify(v)).toString('base64url'))
-      .join('.')
-
-    const signature = crypto.createSign('RSA-SHA256').end(jwt).sign(IdP.privateKey, 'base64url')
-
-    const idToken = `${jwt}.${signature}`
-
-    this.captures.set(`${user}.id_token`, idToken)
-  }
-
-  @given('the IDP {word} token for {word} is issued with following secret:')
-  public async issueSymmetricToken (alg: string, user: string, secret: string): Promise<void> {
-    const jwt = [
-      {
-        typ: 'JWT',
-        alg
-      },
-      {
-        iss: IdP.issuer,
-        sub: `${user}-mock-id`,
-        aud: 'test',
-        iat: Math.floor(Date.now() / 1000),
-        exp: Math.floor((Date.now() + 1000 * 60 * 5) / 1000)
-      }
-    ]
-      .map((v) => Buffer.from(JSON.stringify(v)).toString('base64url'))
-      .join('.')
-
-    const signature = crypto.createHmac(alg.replace(/^HS(\d{3})$/, 'sha$1'), secret)
-      .update(jwt)
-      .digest('base64url')
-
-    const idToken = `${jwt}.${signature}`
-
-    this.captures.set(`${user}.id_token`, idToken)
-  }
-}

package/features/steps/components/octets.tester/operations/diversify.js

@@ -1,14 +0,0 @@
-'use strict'
-
-const { join } = require('node:path')
-const { createReadStream } = require('node:fs')
-
-const lenna = join(__dirname, 'lenna.png')
-
-async function diversify (input, context) {
-  const stream = createReadStream(lenna)
-
-  return context.storages[input.storage].diversify(input.path, 'hello.png', stream)
-}
-
-exports.effect = diversify

package/features/vary.feature

@@ -1,203 +0,0 @@
-Feature: The Vary directive family
-
-  Scenario Outline: Embedding a `<result>` language code
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          vary:languages: [en, fr]
-          GET:
-            vary:embed:
-              name: language  # embed resolved language code as a `name` property of the operation input
-            endpoint: compute
-      """
-    When the following request is received:
-      """
-      GET /echo/ HTTP/1.1
-      accept: application/yaml
-      accept-language: <accept>
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      content-type: application/yaml
-      content-language: <result>
-      vary: accept-language, accept
-
-      Hello <result>
-      """
-    Examples:
-      | accept | result |
-      | en     | en     |
-      | en_US  | en     |
-      | fr     | fr     |
-      | sw     | en     |
-
-  Scenario: Listing languages on the root
-    Given the annotation:
-    """
-    /:
-      vary:languages: [en, fr]
-    """
-    And the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          GET:
-            anonymous: true
-            vary:embed:
-              name: language
-            endpoint: compute
-      """
-    When the following request is received:
-      """
-      GET /echo/ HTTP/1.1
-      accept: application/yaml
-      accept-language: fr
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      content-type: application/yaml
-      content-language: fr
-      """
-
-  Scenario: Embedding a value of an arbitrary header
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          GET:
-            vary:embed:
-              name: :foo
-            endpoint: compute
-      """
-    When the following request is received:
-      """
-      GET /echo/ HTTP/1.1
-      accept: application/yaml
-      foo: bar
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      content-type: application/yaml
-      vary: foo, accept
-
-      Hello bar
-      """
-
-  Scenario: Embedding a `host` header value
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:
-          io:output: true
-          GET:
-            vary:embed:
-              name: :Host
-            endpoint: compute
-      """
-    When the following request is received:
-      """
-      GET /echo/ HTTP/1.1
-      accept: application/yaml
-      foo: bar
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-      content-type: application/yaml
-      vary: accept
-
-      Hello 127.0.0.1:8000
-      """
-
-  Scenario Outline: Embedding a value from the list of options
-    Given the `echo` is running with the following manifest:
-        """yaml
-        exposition:
-          /:
-            io:output: true
-            vary:languages: [en, fr]
-            GET:
-              vary:embed:
-                name:
-                  - :foo
-                  - :bar
-                  - language
-              endpoint: compute
-        """
-    When the following request is received:
-        """
-        GET /echo/ HTTP/1.1
-        accept: application/yaml
-        <header>: <value>
-        """
-    Then the following reply is sent:
-        """
-        200 OK
-        content-type: application/yaml
-        vary: <header>, accept
-
-        Hello <value>
-        """
-    Examples:
-      | header          | value |
-      | foo             | bar   |
-      | bar             | baz   |
-      | accept-language | en    |
-
-  Scenario: Embedding route parameter
-    Given the `echo` is running with the following manifest:
-      """yaml
-      exposition:
-        /:friend:
-          io:output: true
-          GET:
-            vary:embed:
-              name: /:friend
-            endpoint: compute
-      """
-    When the following request is received:
-      """
-      GET /echo/Ken/ HTTP/1.1
-      accept: text/plain
-      """
-    Then the following reply is sent:
-      """
-      200 OK
-
-      Hello Ken
-      """
-
-  Scenario: Adding headers used by defined embeddings to CORS permissions
-    Given the `echo` is running with the following manifest:
-        """yaml
-        exposition:
-          /:
-            io:output: true
-            vary:languages: [en, fr]
-            GET:
-              vary:embed:
-                name:
-                  - language
-                  - :foo
-                  - :FOO
-                  - :bar
-              endpoint: compute
-        """
-    When the following request is received:
-        """
-        OPTIONS / HTTP/1.1
-        origin: https://example.com
-        access-control-request-headers: whatever
-        """
-    Then the following reply is sent:
-        """
-        204 No Content
-        access-control-allow-headers: accept, authorization, content-type, etag, if-match, if-none-match, accept-language, foo, bar
-        """

package/schemas/octets/context.cos.yaml

@@ -1 +0,0 @@
-string

package/schemas/octets/fetch.cos.yaml

@@ -1,3 +0,0 @@
-blob: boolean
-meta: boolean
-_: true

package/schemas/octets/permute.cos.yaml

@@ -1 +0,0 @@
-~

package/schemas/octets/store.cos.yaml

@@ -1,3 +0,0 @@
-accept+: string
-workflow+: <string>
-_: true