@toa.io/extensions.exposition 0.22.1 → 0.24.0-alpha.0

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

@@ -0,0 +1,7 @@
+'use strict'
+
+function foo (input, context) {
+  return context.storages.octets.annotate(input.path, 'foo', 'bar')
+}
+
+exports.effect = foo

package/features/steps/components/pots/manifest.toa.yaml

@@ -8,7 +8,7 @@ entity:
 
 operations:
   transit:
-    concurrency: none
+    query: false
     input:
       title*: ~
       volume*: ~

package/features/streams.feature

@@ -18,9 +18,13 @@ Feature: Reply streams
     Then the following reply is sent:
       """
       201 Created
-      transfer-encoding: chunked
+      content-type: multipart/text; boundary=cut
 
+      --cut
       0
+      --cut
       1
+      --cut
       2
+      --cut--
       """

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/extensions.exposition",
-  "version": "0.22.1",
+  "version": "0.24.0-alpha.0",
   "description": "Toa Exposition",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -17,15 +17,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@toa.io/core": "0.22.1",
-    "@toa.io/generic": "0.22.0",
-    "@toa.io/http": "0.22.0",
-    "@toa.io/schemas": "0.22.0",
-    "@toa.io/streams": "0.22.0",
+    "@toa.io/core": "0.24.0-alpha.0",
+    "@toa.io/generic": "0.24.0-alpha.0",
+    "@toa.io/http": "0.24.0-alpha.0",
+    "@toa.io/schemas": "0.24.0-alpha.0",
+    "@toa.io/streams": "0.24.0-alpha.0",
     "bcryptjs": "2.4.3",
     "cors": "2.8.5",
+    "error-value": "0.3.0",
     "express": "4.18.2",
     "js-yaml": "4.1.0",
+    "matchacho": "0.3.5",
     "msgpackr": "1.9.5",
     "negotiator": "0.6.3",
     "paseto": "3.1.4"
@@ -35,16 +37,21 @@
     "testEnvironment": "node"
   },
   "scripts": {
-    "transpile": "rm -rf transpiled && npx tsc && npm run transpile:basic && npm run transpile:tokens",
+    "test": "jest",
+    "transpile": "rm -rf transpiled && npx tsc && npm run transpile:basic && npm run transpile:tokens && npm run transpile:roles",
     "transpile:basic": "rm -rf ./components/identity.basic/operations && npx tsc -p ./components/identity.basic",
     "transpile:tokens": "rm -rf ./components/identity.tokens/operations && npx tsc -p ./components/identity.tokens",
+    "transpile:roles": "rm -rf ./components/identity.roles/operations && npx tsc -p ./components/identity.roles",
     "features": "npx cucumber-js"
   },
   "devDependencies": {
+    "@toa.io/extensions.storages": "0.24.0-alpha.0",
     "@types/bcryptjs": "2.4.3",
     "@types/cors": "2.8.13",
     "@types/express": "4.17.17",
-    "@types/negotiator": "0.6.1"
+    "@types/fs-extra": "11.0.4",
+    "@types/negotiator": "0.6.1",
+    "fs-extra": "11.1.1"
   },
-  "gitHead": "d1116e1a3c3d881d2204989851596f0715abcb0f"
+  "gitHead": "09a88bdf444bc5dba66dbf0005c382f3526f0296"
 }

package/readme.md

@@ -39,11 +39,12 @@ See [features](features) for more examples.
     </picture>
 </a>
 
-The Exposition extension includes a Service which is an HTTP server with ingress and a Tenant. The
-Service communicates
-with Tenants to discover their resource declarations and exposes them as HTTP resources. An instance
-of the Tenant is
-running within each Composition that has at least one Component with a resource declaration.
+The Exposition extension includes a Service, which is an HTTP server with ingress and a Tenant.
+The Service communicates with Tenants to discover their resource declarations and exposes them as
+HTTP resources.
+An instance of the Tenant is running within each Composition that has at least one Component with a
+resource
+declaration.
 
 ## Resource tree discovery
 
@@ -179,5 +180,7 @@ exposition:
 - [Resource Tree Definition](documentation/tree.md)
 - [Identity authentication](documentation/identity.md)
 - [Access authorization](documentation/access.md)
+- [BLOBs](documentation/octets.md)
 - [Components and resources](documentation/components.md)
+- [Caching](documentation/cache.md)
 - [Features](features)

package/schemas/octets/context.cos.yaml

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

package/schemas/octets/delete.cos.yaml

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

package/schemas/octets/fetch.cos.yaml

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

package/schemas/octets/list.cos.yaml

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

package/schemas/octets/permute.cos.yaml

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

package/schemas/octets/store.cos.yaml

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

package/source/Gateway.ts

@@ -35,9 +35,6 @@ export class Gateway extends Connector {
   }
 
   private async process (request: http.IncomingMessage): Promise<http.OutgoingMessage> {
-    if (request.path[request.path.length - 1] !== '/')
-      throw new http.NotFound('Trailing slash is required.')
-
     const match = this.tree.match(request.path)
 
     if (match === null)
@@ -60,11 +57,19 @@ export class Gateway extends Connector {
   private async call
   (method: Method<Endpoint, Directives>, request: http.IncomingMessage, parameters: Parameter[]):
   Promise<http.OutgoingMessage> {
+    if (request.path[request.path.length - 1] !== '/')
+      throw new http.NotFound('Trailing slash is required.')
+
+    if (request.encoder === null)
+      throw new http.NotAcceptable()
+
     if (method.endpoint === null)
       throw new http.MethodNotAllowed()
 
+    const body = await request.parse()
+
     const reply = await method.endpoint
-      .call(request.body, request.query, parameters)
+      .call(body, request.query, parameters)
       .catch(rethrow) as Maybe<unknown>
 
     if (reply instanceof Error)

package/source/HTTP/Server.fixtures.ts

@@ -17,17 +17,13 @@ const app = {
 } as unknown as jest.Mock<Express>
 
 export function createRequest (req: Partial<Request> = {}, content: string | Buffer = ''):
-jest.MockedObject<Request> {
+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<Request>
-}
-
-export function createIncomingMessage (path: string, method: string = 'GET'): IncomingMessage {
-  return { method, path, headers: {}, body: undefined, query: {} }
+  return stream as unknown as jest.MockedObject<IncomingMessage>
 }
 
 export const res = {

package/source/HTTP/Server.test.ts

@@ -93,43 +93,22 @@ it('should send 501 on unknown method', async () => {
   expect(res.sendStatus).toHaveBeenCalledWith(501)
 })
 
-describe('request', () => {
-  const process = jest.fn(async () => ({})) as unknown as Processing
-
-  beforeEach(() => {
-    server.attach(process)
-  })
-
-  it('should pass decoded request', async () => {
-    const path = generate()
-    const method = generate()
-    const headers = { 'content-type': 'application/json' }
-    const body = { [generate()]: generate() }
-    const json = JSON.stringify(body)
-    const req = createRequest({ path, method, headers }, json)
-
-    await use(req)
-
-    expect(process).toHaveBeenCalledWith(expect.objectContaining({ path, method, headers, body }))
-  })
-})
-
 describe('result', () => {
   it('should send status code 200 if the result has a value', async () => {
-    const process = async (): Promise<OutgoingMessage> => ({ headers: {}, body: generate() })
     const req = createRequest()
 
-    server.attach(process)
+    server.attach(async (): Promise<OutgoingMessage> => ({
+      headers: new Headers(), body: generate()
+    }))
     await use(req)
 
     expect(res.status).toHaveBeenCalledWith(200)
   })
 
   it('should send status code 204 if the result has no value', async () => {
-    const process = async (): Promise<OutgoingMessage> => ({ headers: {} })
     const req = createRequest()
 
-    server.attach(process)
+    server.attach(async (): Promise<OutgoingMessage> => ({ headers: new Headers() }))
     await use(req)
 
     expect(res.status).toHaveBeenCalledWith(204)
@@ -139,17 +118,16 @@ describe('result', () => {
     const body = { [generate()]: generate() }
     const json = JSON.stringify(body)
     const buf = Buffer.from(json)
-    const process = async (): Promise<OutgoingMessage> => ({ headers: {}, body })
     const req = createRequest({ headers: { accept: 'application/json' } })
 
-    server.attach(process)
+    server.attach(async (): Promise<OutgoingMessage> => ({ headers: new Headers(), body }))
     await use(req)
 
-    expect(res.send).toHaveBeenCalledWith(buf)
+    expect(res.end).toHaveBeenCalledWith(buf)
   })
 
   it('should return 500 on exception', async () => {
-    const process = async (): Promise<OutgoingMessage> => {
+    async function process (): Promise<OutgoingMessage> {
       throw new Error('Bad')
     }
 
@@ -170,7 +148,7 @@ describe('result', () => {
     const message = generate()
     const req = createRequest()
 
-    const process = async (): Promise<OutgoingMessage> => {
+    async function process (): Promise<OutgoingMessage> {
       throw new Error(message)
     }
 
@@ -184,7 +162,7 @@ describe('result', () => {
     const req = createRequest()
     const message = generate()
 
-    const process = async (): Promise<OutgoingMessage> => {
+    async function process (): Promise<OutgoingMessage> {
       throw new BadRequest(message)
     }
 

package/source/HTTP/Server.ts

@@ -1,9 +1,14 @@
+import fs from 'node:fs'
+import os from 'node:os'
 import express from 'express'
 import cors from 'cors'
 import { Connector } from '@toa.io/core'
 import { promex } from '@toa.io/generic'
+import Negotiator from 'negotiator'
 import { read, write, type IncomingMessage, type OutgoingMessage } from './messages'
 import { ClientError, Exception } from './exceptions'
+import { formats, types } from './formats'
+import type { Format } from './formats'
 import type * as http from 'node:http'
 import type { Express, Request, Response, NextFunction } from 'express'
 
@@ -19,8 +24,10 @@ export class Server extends Connector {
     this.debug = debug
   }
 
-  public static create (options: Partial<Properties> = {}): Server {
-    const properties: Properties = Object.assign({}, defaults(), options)
+  public static create (options?: Partial<Properties>): Server {
+    const properties: Properties = options === undefined
+      ? DEFAULTS
+      : { ...DEFAULTS, ...options }
 
     const app = express()
 
@@ -32,8 +39,8 @@ export class Server extends Connector {
   }
 
   public attach (process: Processing): void {
-    this.app.use((request: Request, response: Response): void => {
-      this.read(request)
+    this.app.use((request: any, response: Response) => {
+      this.extend(request)
         .then(process)
         .then(this.success(request, response))
         .catch(this.fail(request, response))
@@ -62,14 +69,16 @@ export class Server extends Connector {
     console.info('HTTP Server has been stopped.')
   }
 
-  private async read (request: Request): Promise<IncomingMessage> {
-    const { method, path, headers, query } = request
-    const body = await read(request)
+  private async extend (request: IncomingMessage): Promise<IncomingMessage> {
+    const message = request as unknown as IncomingMessage
 
-    return { method, path, headers, query, body }
+    message.encoder = negotiate(request)
+    message.parse = async <T> (): Promise<T> => await read(request)
+
+    return message
   }
 
-  private success (request: Request, response: Response) {
+  private success (request: IncomingMessage, response: Response) {
     return (message: OutgoingMessage) => {
       let status = message.status
 
@@ -79,34 +88,35 @@ export class Server extends Connector {
         else if (message.body === undefined) status = 204
         else status = 200
 
-      response
-        .status(status)
-        .set(message.headers)
+      response.status(status)
+      message.headers?.forEach((value, key) => response.set(key, value))
 
       if (message.body !== undefined && message.body !== null)
-        write(request, response, message.body)
+        write(request, response, message)
       else
         response.end()
     }
   }
 
-  private fail (request: Request, response: Response) {
-    return (exception: Error) => {
-      let status = 500
+  private fail (request: IncomingMessage, response: Response) {
+    return async (exception: Error) => {
+      if (!request.complete)
+        await adam(request)
 
-      if (exception instanceof Exception)
-        status = exception.status
-
-      const outputAllowed = exception instanceof ClientError || this.debug
+      const status = exception instanceof Exception
+        ? exception.status
+        : 500
 
       response.status(status)
 
+      const outputAllowed = exception instanceof ClientError || this.debug
+
       if (outputAllowed) {
         const body = exception instanceof Exception
           ? exception.body
           : (exception.stack ?? exception.message)
 
-        write(request, response, body)
+        write(request, response, { body })
       } else
         response.end()
     }
@@ -120,16 +130,33 @@ function supportedMethods (methods: Set<string>) {
   }
 }
 
+function negotiate (request: Request): Format | null {
+  const negotiator = new Negotiator(request)
+  const mediaType = negotiator.mediaType(types)
+
+  return mediaType === undefined ? null : formats[mediaType]
+}
+
+// https://github.com/whatwg/fetch/issues/1254
+async function adam (request: Request): Promise<void> {
+  const completed = promex()
+  const devnull = fs.createWriteStream(os.devNull)
+
+  request
+    .on('end', completed.callback)
+    .pipe(devnull)
+
+  return await completed
+}
+
+const DEFAULTS = {
+  methods: new Set<string>(['GET', 'OPTIONS', 'POST', 'PUT', 'PATCH', 'DELETE']),
+  debug: false
+}
+
 interface Properties {
   methods: Set<string>
   debug: boolean
 }
 
-function defaults (): Properties {
-  return {
-    methods: new Set<string>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']),
-    debug: false
-  }
-}
-
 export type Processing = (input: IncomingMessage) => Promise<OutgoingMessage>

package/source/HTTP/exceptions.ts

@@ -1,5 +1,3 @@
-import { types } from './formats'
-
 export class Exception extends Error {
   public readonly status: number
   public readonly body?: any
@@ -50,21 +48,13 @@ export class MethodNotAllowed extends ClientError {
   }
 }
 
-class MediaTypeException extends ClientError {
-  private static readonly message = 'Supported media types:\n- ' + types.join('\n- ')
-
-  protected constructor (status: number) {
-    super(status, MediaTypeException.message)
-  }
-}
-
-export class NotAcceptable extends MediaTypeException {
+export class NotAcceptable extends ClientError {
   public constructor () {
     super(406)
   }
 }
 
-export class UnsupportedMediaType extends MediaTypeException {
+export class UnsupportedMediaType extends ClientError {
   public constructor () {
     super(415)
   }

package/source/HTTP/formats/index.ts

@@ -5,15 +5,18 @@ import * as msgpack from './msgpack'
 import * as text from './text'
 
 export const formats: Record<string, Format> = {
-  'application/yaml': yaml,
-  'application/msgpack': msgpack,
-  'application/json': json,
-  'text/plain': text
+  [msgpack.type]: msgpack,
+  [yaml.type]: yaml,
+  [json.type]: json,
+  [text.type]: text
 }
 
 export const types = Object.keys(formats)
 
 export interface Format {
+  readonly type: string
+  readonly multipart: string
+
   encode: (value: any) => Buffer
   decode: (buffer: Buffer) => any
 }

package/source/HTTP/formats/json.ts

@@ -1,5 +1,8 @@
 import { Buffer } from 'node:buffer'
 
+export const type = 'application/json'
+export const multipart = 'multipart/json'
+
 export function decode (buffer: Buffer): any {
   const text = buffer.toString()
 

package/source/HTTP/formats/msgpack.ts

@@ -1,6 +1,9 @@
 import { type Buffer } from 'node:buffer'
 import * as msgpack from 'msgpackr'
 
+export const type = 'application/msgpack'
+export const multipart = 'multipart/msgpack'
+
 export function decode (buffer: Buffer): any {
   return msgpack.decode(buffer)
 }

package/source/HTTP/formats/text.ts

@@ -1,5 +1,8 @@
 import { Buffer } from 'node:buffer'
 
+export const type = 'text/plain'
+export const multipart = 'multipart/text'
+
 export function decode (buffer: Buffer): any {
   return buffer.toString()
 }

package/source/HTTP/formats/yaml.ts

@@ -1,6 +1,9 @@
 import { Buffer } from 'node:buffer'
 import * as yaml from 'js-yaml'
 
+export const type = 'application/yaml'
+export const multipart = 'multipart/yaml'
+
 export function decode (buffer: Buffer): any {
   const text = buffer.toString()
 

package/source/HTTP/messages.test.ts

@@ -1,9 +1,8 @@
-import { Buffer } from 'node:buffer'
 import { generate } from 'randomstring'
 import * as msgpack from 'msgpackr'
-import { type OutgoingMessage, read, write } from './messages'
-import { createRequest, res } from './Server.fixtures'
-import { BadRequest, NotAcceptable, UnsupportedMediaType } from './exceptions'
+import { read } from './messages'
+import { createRequest } from './Server.fixtures'
+import { BadRequest, UnsupportedMediaType } from './exceptions'
 
 beforeEach(() => {
   jest.clearAllMocks()
@@ -69,48 +68,3 @@ describe('read', () => {
     await expect(read(request)).rejects.toThrow(BadRequest)
   })
 })
-
-describe('write', () => {
-  it('should write encoded response', async () => {
-    const value = { [generate()]: generate() }
-    const json = JSON.stringify(value)
-    const buf = Buffer.from(json)
-    const headers = { accept: 'application/json' }
-    const request = createRequest({ headers }, buf)
-
-    write(request, res, value)
-
-    expect(res.set).toHaveBeenCalledWith('content-type', 'application/json')
-    expect(res.send).toHaveBeenCalledWith(buf)
-  })
-
-  it('should throw on unsupported response media type', async () => {
-    const headers = { accept: 'wtf/' + generate() }
-    const request = createRequest({ headers })
-    const value = generate()
-
-    expect(() => {
-      write(request, res, value)
-    }).toThrow(NotAcceptable)
-  })
-
-  it('should use application/yaml as default', async () => {
-    const request = createRequest()
-    const message: OutgoingMessage = { headers: {}, body: 'hello' }
-
-    write(request, res, message)
-
-    expect(res.set).toHaveBeenCalledWith('content-type', 'application/yaml')
-    expect(res.send).toHaveBeenCalled()
-  })
-
-  it('should negotiate', async () => {
-    const headers = { accept: 'text/html, application/*;q=0.2, image/jpeg;q=0.8' }
-    const request = createRequest({ headers })
-    const message: OutgoingMessage = { headers: {}, body: 'hello' }
-
-    write(request, res, message)
-
-    expect(res.set).toHaveBeenCalledWith('content-type', 'application/yaml')
-  })
-})