@toa.io/extensions.exposition 1.0.0-alpha.284 → 1.0.0-alpha.286

package/features/steps/HTTP.ts

@@ -17,25 +17,25 @@ const { binding, then, when } = tsflow
 export class HTTP extends http.Agent {
   private readonly gateway: Gateway
 
-  public constructor (gateway: Gateway, parameters: Parameters, captures: Captures) {
+  public constructor(gateway: Gateway, parameters: Parameters, captures: Captures) {
     super(parameters.origin, captures)
     this.gateway = gateway
   }
 
   @when('the following request is received:')
-  public override async request (input: string): Promise<any> {
+  public override async request(input: string): Promise<any> {
     await this.gateway.start()
 
     await super.request(input)
   }
 
   @then('the following reply is sent:')
-  public override responseIncludes (expected: string): void {
+  public override responseIncludes(expected: string): void {
     super.responseIncludes(expected)
   }
 
   @then('response body contains {word}-encoded value:')
-  public async bodyIs (format: string, yaml: string): Promise<void> {
+  public async bodyIs(format: string, yaml: string): Promise<void> {
     assert.ok(this.bytes !== null, 'Response body is not available')
 
     const value = encoders[format]?.(this.bytes)
@@ -45,12 +45,12 @@ export class HTTP extends http.Agent {
   }
 
   @then('the reply does not contain:')
-  public override responseExcludes (expected: string): void {
+  public override responseExcludes(expected: string): void {
     super.responseExcludes(expected)
   }
 
   @when('the stream of `{word}` is received with the following headers:')
-  public async streamRequest (filename: string, head: string): Promise<any> {
+  public async streamRequest(filename: string, head: string): Promise<any> {
     const stream = open(filename)
 
     await this.gateway.start()
@@ -58,30 +58,27 @@ export class HTTP extends http.Agent {
   }
 
   @then('the stream equals to `{word}` is sent with the following headers:')
-  public async responseStreamMatch (filename: string, head: string): Promise<any> {
+  public async responseStreamMatch(filename: string, head: string): Promise<any> {
     const stream = open(filename)
 
     await super.streamMatch(head, stream)
   }
 
   @when('the following request is interrupted after {float} second(s):')
-  public async interrupt (delay: number, input: string): Promise<any> {
+  public async interrupt(delay: number, input: string): Promise<any> {
     const controller = new AbortController()
 
     await this.gateway.start()
 
     setTimeout(() => {
-      if (pending)
-        controller.abort()
-      else
-        console.error('Request cannot be interrupted as it is already completed')
+      if (pending) controller.abort()
+      else console.error('Request cannot be interrupted as it is already completed')
     }, delay * 1000)
 
     let pending = true
 
     await super.fetch(input, { signal: controller.signal }).catch((e) => {
-      if (e.name !== 'AbortError')
-        throw e
+      if (e.name !== 'AbortError') throw e
     })
 
     pending = false
@@ -90,7 +87,7 @@ export class HTTP extends http.Agent {
 
 const FILES_DIR = path.resolve(import.meta.dirname, '../../../storages/source/test')
 
-function open (filename: string): Readable {
+function open(filename: string): Readable {
   return fs.createReadStream(path.join(FILES_DIR, filename))
 }
 

package/features/steps/IDP.ts

@@ -20,12 +20,12 @@ export class IDP {
   private static authCodes = new Map<string, AuthCode>()
   private readonly captures: Captures
 
-  public constructor (captures: Captures) {
+  public constructor(captures: Captures) {
     this.captures = captures
   }
 
   @afterAll()
-  public static async stop (): Promise<void> {
+  public static async stop(): Promise<void> {
     if (this.server instanceof http.Server) {
       this.server.close()
       await once(this.server, 'close')
@@ -33,25 +33,27 @@ export class IDP {
   }
 
   @given(/local IDP is running/i)
-  public async start (): Promise<void> {
+  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
-    })
+    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' })
-      }]
+      keys: [
+        {
+          use: 'sig',
+          alg: 'RS256',
+          ...publicKey.export({ format: 'jwk' })
+        }
+      ]
     })
 
     const JWK_ENDPOINT = '/.well-known/jwks'
@@ -71,79 +73,83 @@ export class IDP {
           response.end(jwk)
           break
 
-        case '/.well-known/openid-configuration': {
-          const openIdConfiguration = JSON.stringify({
-            issuer: IDP.issuer,
-            jwks_uri: IDP.issuer + JWK_ENDPOINT,
-            authorization_endpoint: IDP.issuer + AUTH_ENDPOINT,
-            token_endpoint: IDP.issuer + TOKEN_ENDPOINT,
-            response_types_supported: ['id_token', 'code'],
-            grant_types_supported: ['authorization_code'],
-            subject_types_supported: ['public'],
-            id_token_signing_alg_values_supported: ['RS256'],
-            scopes_supported: ['openid', 'email', 'profile']
-          })
-
-          response.writeHead(200, {
-            'Content-Type': 'application/json',
-            'Cache-Control': 'public, max-age=3600',
-            'Content-Length': openIdConfiguration.length
-          })
-
-          response.end(openIdConfiguration)
-        }
-
-          break
-
-        case TOKEN_ENDPOINT: {
-          if (request.method !== 'POST') {
-            response.writeHead(405, { 'Content-Type': 'text/plain' })
-            response.end('Method not allowed')
-
-            return
-          }
-
-          const buf = await buffer(request)
-          const body = buf.toString('utf8')
-
-          const params = new URLSearchParams(body)
-          const grantType = params.get('grant_type')!
-          const code = params.get('code')!
-          const redirectUri = params.get('redirect_uri')!
-          const clientId = params.get('client_id')!
-
-          if (grantType !== 'authorization_code' || !code || !clientId) {
-            response.writeHead(400, { 'Content-Type': 'application/json' })
-            response.end(JSON.stringify({ error: 'invalid_request' }))
+        case '/.well-known/openid-configuration':
+          {
+            const openIdConfiguration = JSON.stringify({
+              issuer: IDP.issuer,
+              jwks_uri: IDP.issuer + JWK_ENDPOINT,
+              authorization_endpoint: IDP.issuer + AUTH_ENDPOINT,
+              token_endpoint: IDP.issuer + TOKEN_ENDPOINT,
+              response_types_supported: ['id_token', 'code'],
+              grant_types_supported: ['authorization_code'],
+              subject_types_supported: ['public'],
+              id_token_signing_alg_values_supported: ['RS256'],
+              scopes_supported: ['openid', 'email', 'profile']
+            })
+
+            response.writeHead(200, {
+              'Content-Type': 'application/json',
+              'Cache-Control': 'public, max-age=3600',
+              'Content-Length': openIdConfiguration.length
+            })
+
+            response.end(openIdConfiguration)
           }
 
-          const codeData = IDP.authCodes.get(code)
-
-          if (!codeData ||
-            codeData.expiresAt < Date.now() ||
-            codeData.clientId !== clientId ||
-            (redirectUri && codeData.redirectUri !== redirectUri)) {
-            response.writeHead(400, { 'Content-Type': 'application/json' })
-            response.end(JSON.stringify({ error: 'invalid_grant' }))
+          break
 
-            return
+        case TOKEN_ENDPOINT:
+          {
+            if (request.method !== 'POST') {
+              response.writeHead(405, { 'Content-Type': 'text/plain' })
+              response.end('Method not allowed')
+
+              return
+            }
+
+            const buf = await buffer(request)
+            const body = buf.toString('utf8')
+
+            const params = new URLSearchParams(body)
+            const grantType = params.get('grant_type')!
+            const code = params.get('code')!
+            const redirectUri = params.get('redirect_uri')!
+            const clientId = params.get('client_id')!
+
+            if (grantType !== 'authorization_code' || !code || !clientId) {
+              response.writeHead(400, { 'Content-Type': 'application/json' })
+              response.end(JSON.stringify({ error: 'invalid_request' }))
+            }
+
+            const codeData = IDP.authCodes.get(code)
+
+            if (
+              !codeData ||
+              codeData.expiresAt < Date.now() ||
+              codeData.clientId !== clientId ||
+              (redirectUri && codeData.redirectUri !== redirectUri)
+            ) {
+              response.writeHead(400, { 'Content-Type': 'application/json' })
+              response.end(JSON.stringify({ error: 'invalid_grant' }))
+
+              return
+            }
+
+            const accessToken = crypto.randomBytes(32).toString('hex')
+            const idToken = this.generateIdToken(codeData.sub, codeData.email, clientId)
+
+            IDP.authCodes.delete(code)
+
+            response.writeHead(200, { 'Content-Type': 'application/json' }).end(
+              JSON.stringify({
+                access_token: accessToken,
+                token_type: 'Bearer',
+                id_token: idToken,
+                expires_in: 3600
+              })
+            )
           }
 
-          const accessToken = crypto.randomBytes(32).toString('hex')
-          const idToken = this.generateIdToken(codeData.sub, codeData.email, clientId)
-
-          IDP.authCodes.delete(code)
-
-          response
-            .writeHead(200, { 'Content-Type': 'application/json' })
-            .end(JSON.stringify({
-              access_token: accessToken,
-              token_type: 'Bearer',
-              id_token: idToken,
-              expires_in: 3600
-            }))
-        }
-
           break
 
         default:
@@ -152,7 +158,8 @@ export class IDP {
       }
     })
 
-    server.listen(44444, 'localhost')
+    // in Toa's own block, and out of the ephemeral range an arbitrary port would sit in
+    server.listen(31005, 'localhost')
     await once(server, 'listening')
 
     const address = server.address() as AddressInfo
@@ -163,7 +170,7 @@ export class IDP {
   }
 
   @given('the IDP token for {word} is issued')
-  public async issueToken (user: string): Promise<void> {
+  public async issueToken(user: string): Promise<void> {
     assert.ok(IDP.privateKey, 'IdP private key is not available')
 
     const jwt = [
@@ -183,7 +190,10 @@ export class IDP {
       .map((v) => Buffer.from(JSON.stringify(v)).toString('base64url'))
       .join('.')
 
-    const signature = crypto.createSign('RSA-SHA256').end(jwt).sign(IDP.privateKey, 'base64url')
+    const signature = crypto
+      .createSign('RSA-SHA256')
+      .end(jwt)
+      .sign(IDP.privateKey, 'base64url')
 
     const idToken = `${jwt}.${signature}`
 
@@ -191,7 +201,7 @@ export class IDP {
   }
 
   @given('the IDP random token is issued')
-  public async issueNewToken (): Promise<void> {
+  public async issueNewToken(): Promise<void> {
     assert.ok(IDP.privateKey, 'IdP private key is not available')
 
     const sub = Math.random().toString(36).substring(7)
@@ -213,7 +223,10 @@ export class IDP {
       .map((v) => Buffer.from(JSON.stringify(v)).toString('base64url'))
       .join('.')
 
-    const signature = crypto.createSign('RSA-SHA256').end(jwt).sign(IDP.privateKey, 'base64url')
+    const signature = crypto
+      .createSign('RSA-SHA256')
+      .end(jwt)
+      .sign(IDP.privateKey, 'base64url')
 
     const idToken = `${jwt}.${signature}`
 
@@ -223,7 +236,11 @@ export class IDP {
   }
 
   @given('the IDP {word} token for {word} is issued with following secret:')
-  public async issueSymmetricToken (alg: string, user: string, secret: string): Promise<void> {
+  public async issueSymmetricToken(
+    alg: string,
+    user: string,
+    secret: string
+  ): Promise<void> {
     const jwt = [
       {
         typ: 'JWT',
@@ -240,7 +257,8 @@ export class IDP {
       .map((v) => Buffer.from(JSON.stringify(v)).toString('base64url'))
       .join('.')
 
-    const signature = crypto.createHmac(alg.replace(/^HS(\d{3})$/, 'sha$1'), secret)
+    const signature = crypto
+      .createHmac(alg.replace(/^HS(\d{3})$/, 'sha$1'), secret)
       .update(jwt)
       .digest('base64url')
 
@@ -250,7 +268,7 @@ export class IDP {
   }
 
   @given('ID token with jti is issued for {word}')
-  public async issueTokenWithJti (user: string): Promise<void> {
+  public async issueTokenWithJti(user: string): Promise<void> {
     assert.ok(IDP.privateKey, 'IdP private key is not available')
 
     const jwt = [
@@ -271,7 +289,10 @@ export class IDP {
       .map((v) => Buffer.from(JSON.stringify(v)).toString('base64url'))
       .join('.')
 
-    const signature = crypto.createSign('RSA-SHA256').end(jwt).sign(IDP.privateKey, 'base64url')
+    const signature = crypto
+      .createSign('RSA-SHA256')
+      .end(jwt)
+      .sign(IDP.privateKey, 'base64url')
 
     const idToken = `${jwt}.${signature}`
 
@@ -279,7 +300,7 @@ export class IDP {
   }
 
   @given('auth code for {word} is issued for {word}')
-  public async issueAuthCode (user: string, redirectUri: string): Promise<void> {
+  public async issueAuthCode(user: string, redirectUri: string): Promise<void> {
     const code = crypto.randomBytes(16).toString('hex')
     const email = user + '@test.local'
     const clientId = 'nex'
@@ -300,7 +321,7 @@ export class IDP {
     this.captures.set(`${user}.code_credentials`, base64)
   }
 
-  private generateIdToken (sub: string, email: string, clientId: string): string {
+  private generateIdToken(sub: string, email: string, clientId: string): string {
     assert.ok(IDP.privateKey, 'IdP private key is not available')
     assert.ok(IDP.issuer, 'IdP issuer is not available')
 
@@ -321,7 +342,10 @@ export class IDP {
       .map((v) => Buffer.from(JSON.stringify(v)).toString('base64url'))
       .join('.')
 
-    const signature = crypto.createSign('RSA-SHA256').end(jwt).sign(IDP.privateKey, 'base64url')
+    const signature = crypto
+      .createSign('RSA-SHA256')
+      .end(jwt)
+      .sign(IDP.privateKey, 'base64url')
 
     return `${jwt}.${signature}`
   }

package/features/steps/Identity.ts

@@ -13,14 +13,14 @@ export class Identity {
   private readonly http: http.Agent
   private readonly variables: Captures
 
-  public constructor (gateway: Gateway, parameters: Parameters, captures: Captures) {
+  public constructor(gateway: Gateway, parameters: Parameters, captures: Captures) {
     this.gateway = gateway
     this.http = new http.Agent(parameters.origin, captures)
     this.variables = captures
   }
 
   @given('transient identity {word}')
-  public async transient (as: string): Promise<Principal> {
+  public async transient(as: string): Promise<Principal> {
     await this.gateway.start()
 
     await this.http.request(`
@@ -43,7 +43,7 @@ export class Identity {
   }
 
   @given('transient identity')
-  public async anonymous (): Promise<Principal> {
+  public async anonymous(): Promise<Principal> {
     return await this.transient('identity')
   }
 }

package/features/steps/OTP.ts

@@ -12,12 +12,12 @@ export class OTP {
   private captures: Captures
   private otp: Remote | null = null
 
-  public constructor (captures: Captures) {
+  public constructor(captures: Captures) {
     this.captures = captures
   }
 
   @given('OTP for `{word}` in `{word}` authority is issued')
-  public async issue (username: string, authority: string): Promise<void> {
+  public async issue(username: string, authority: string): Promise<void> {
     this.otp ??= await this.connect()
 
     const reply = await this.otp.invoke('issue', {
@@ -34,7 +34,7 @@ export class OTP {
     this.captures.set(`${username}.otp`, credentials)
   }
 
-  private async connect (): Promise<Remote> {
+  private async connect(): Promise<Remote> {
     const locator = new Locator('otp', 'identity')
 
     return await boot.remote(locator)

package/features/steps/Parameters.ts

@@ -4,11 +4,18 @@ import { setDefaultTimeout } from '@cucumber/cucumber'
 
 dotenv.config({ path: join(import.meta.dirname, '.env') })
 
+/**
+ * Not `PORT` and `PROBE`, which a deployment serves the gateway on: an application built on
+ * Toa is served on this machine too, and its own gateway holds those. See CONTRIBUTING.md.
+ */
+export const PORT = 31000
+export const PROBE = 31004
+
 export class Parameters {
   public readonly origin: string
 
-  public constructor () {
-    this.origin = 'http://127.0.0.1:8000'
+  public constructor() {
+    this.origin = `http://127.0.0.1:${PORT}`
   }
 }
 
@@ -29,7 +36,7 @@ process.env.TOA_TELEMETRY_READY ??= JSON.stringify(false)
 process.env.TOA_TELEMETRY_TRACES ??= JSON.stringify({
   exporters: {
     console: null,
-    otlp: { endpoint: 'http://localhost:4318' }
+    otlp: { endpoint: 'http://localhost:31061' }
   }
 })
 
@@ -49,13 +56,16 @@ const CLOUDINARY = {
     transformations: [
       {
         extension: 'icon',
-        transformation: [{
-          width: 48,
-          height: 48,
-          crop: 'fill'
-        }, {
-          border: '10px_solid_white'
-        }],
+        transformation: [
+          {
+            width: 48,
+            height: 48,
+            crop: 'fill'
+          },
+          {
+            border: '10px_solid_white'
+          }
+        ],
         optional: true
       },
       {

package/features/steps/Probe.ts

@@ -1,7 +1,8 @@
 import assert from 'node:assert'
 import { Agent, request } from 'undici'
 import tsflow from 'cucumber-tsflow'
-import { PATH, PROBE } from '../../source/HTTP/index.js'
+import { PATH } from '../../source/HTTP/index.js'
+import { PROBE } from './Parameters.js'
 
 const { after, binding, then, when } = tsflow
 
@@ -12,8 +13,10 @@ export class Probe {
   private headers: Record<string, string> = {}
 
   @when('the ready probe is requested')
-  public async request (): Promise<void> {
-    const response = await request(`http://127.0.0.1:${PROBE}${PATH}`, { dispatcher: this.agent })
+  public async request(): Promise<void> {
+    const response = await request(`http://127.0.0.1:${PROBE}${PATH}`, {
+      dispatcher: this.agent
+    })
 
     this.status = response.statusCode
     this.headers = response.headers as Record<string, string>
@@ -22,15 +25,14 @@ export class Probe {
   }
 
   @then('the ready probe answers {int}')
-  public answers (status: number): void {
+  public answers(status: number): void {
     assert.equal(this.status, status)
 
-    if (status === 200)
-      assert.equal(this.headers['cache-control'], 'no-store')
+    if (status === 200) assert.equal(this.headers['cache-control'], 'no-store')
   }
 
   @after()
-  public async close (): Promise<void> {
+  public async close(): Promise<void> {
     await this.agent.close()
   }
 }