@toa.io/extensions.exposition 1.0.0-alpha.2 → 1.0.0-alpha.200

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

@@ -1,40 +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 {
-    identity: string;
-    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,48 +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 {
-  identity: string
-  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.path
-  const claim = request.headers['content-type']
-
-  return context.storages[storage].put(path, request, { claim, accept, meta })
-}
-
-exports.effect = store

package/documentation/vary.md

@@ -1,69 +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
-  /:
-    vary:languages: [en, fr]
-    GET:
-      vary:embed:
-        lang: language # predefined embeddings
-        realm: realm
-        token: :x-access-token # raw header value
-      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
-
-Keys 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.
-
-### 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,120 +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)
-  }
-}

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,150 +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:
-        /:
-          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:
-        /:
-          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:
-        /:
-          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 Outline: Embedding a value from the list of options
-    Given the `echo` is running with the following manifest:
-        """yaml
-        exposition:
-          /:
-            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: Adding headers used by defined embeddings to CORS permissions
-    Given the `echo` is running with the following manifest:
-        """yaml
-        exposition:
-          /:
-            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: http://example.com
-        access-control-request-headers: whatever
-        """
-    Then the following reply is sent:
-        """
-        204 No Content
-        access-control-allow-headers: accept, authorization, content-type, 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

package/source/HTTP/Server.fixtures.ts

@@ -1,40 +0,0 @@
-import { Readable } from 'stream'
-import type { IncomingMessage } from './messages'
-import type * as http from 'node:http'
-import type { NextFunction, Response, Express, Request } from 'express'
-import type { CorsOptions } from 'cors'
-
-const server = {
-  close: jest.fn()
-} as unknown as jest.Mock<http.Server>
-
-const app = {
-  enable: jest.fn(),
-  disable: jest.fn(),
-  use: jest.fn(),
-  listen: jest.fn(() => server)
-} as unknown as jest.Mock<Express>
-
-export function createRequest (req: Partial<Request> = {}, content: string | Buffer = ''):
-jest.MockedObject<IncomingMessage> {
-  const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content)
-  const stream = Readable.from(buffer)
-
-  Object.assign(stream, { headers: {} }, req)
-
-  return stream as unknown as jest.MockedObject<IncomingMessage>
-}
-
-export const res = {
-  status: jest.fn(() => res),
-  sendStatus: jest.fn(() => res),
-  set: jest.fn(() => res),
-  send: jest.fn(() => res),
-  end: jest.fn(() => res)
-} as unknown as jest.MockedObject<Response>
-
-export const next = jest.fn() as unknown as NextFunction
-
-export const express = jest.fn(() => app)
-
-export const cors = jest.fn((_: CorsOptions) => () => undefined)