@toa.io/extensions.exposition 0.22.1 → 0.23.0-dev.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/extensions.exposition",
-  "version": "0.22.1",
+  "version": "0.23.0-dev.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.23.0-dev.0",
+    "@toa.io/generic": "0.23.0-dev.0",
+    "@toa.io/http": "0.23.0-dev.0",
+    "@toa.io/schemas": "0.23.0-dev.0",
+    "@toa.io/streams": "0.23.0-dev.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,18 @@
     "testEnvironment": "node"
   },
   "scripts": {
+    "test": "jest",
     "transpile": "rm -rf transpiled && npx tsc && npm run transpile:basic && npm run transpile:tokens",
     "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",
     "features": "npx cucumber-js"
   },
   "devDependencies": {
+    "@toa.io/extensions.storages": "0.23.0-dev.0",
     "@types/bcryptjs": "2.4.3",
     "@types/cors": "2.8.13",
     "@types/express": "4.17.17",
     "@types/negotiator": "0.6.1"
   },
-  "gitHead": "d1116e1a3c3d881d2204989851596f0715abcb0f"
+  "gitHead": "19d4af8ff3b8a1a8f191644f44113c88de4bb404"
 }

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,6 @@ 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)
 - [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,20 @@ 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: {}, 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: {} }))
     await use(req)
 
     expect(res.status).toHaveBeenCalledWith(204)
@@ -139,17 +116,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: {}, 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 +146,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 +160,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

@@ -2,8 +2,11 @@ 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'
 
@@ -32,8 +35,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): void => {
+      this.extend(request)
         .then(process)
         .then(this.success(request, response))
         .catch(this.fail(request, response))
@@ -62,14 +65,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
 
@@ -84,31 +89,34 @@ export class Server extends Connector {
         .set(message.headers)
 
       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) {
+  private fail (request: IncomingMessage, response: Response) {
     return (exception: Error) => {
-      let status = 500
+      const status = exception instanceof Exception
+        ? exception.status
+        : 500
 
-      if (exception instanceof Exception)
-        status = exception.status
+      response.status(status)
 
       const outputAllowed = exception instanceof ClientError || this.debug
 
-      response.status(status)
-
       if (outputAllowed) {
         const body = exception instanceof Exception
           ? exception.body
           : (exception.stack ?? exception.message)
 
-        write(request, response, body)
+        write(request, response, { body })
       } else
         response.end()
+
+      // stop accepting request
+      if (!request.complete)
+        request.destroy()
     }
   }
 }
@@ -120,6 +128,13 @@ 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]
+}
+
 interface Properties {
   methods: Set<string>
   debug: boolean
@@ -127,7 +142,7 @@ interface Properties {
 
 function defaults (): Properties {
   return {
-    methods: new Set<string>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']),
+    methods: new Set<string>(['GET', 'OPTIONS', 'POST', 'PUT', 'PATCH', 'DELETE']),
     debug: false
   }
 }

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

package/source/HTTP/messages.ts

@@ -1,23 +1,28 @@
 import { type IncomingHttpHeaders, type OutgoingHttpHeaders } from 'node:http'
 import { Readable } from 'node:stream'
 import { type Request, type Response } from 'express'
-import Negotiator from 'negotiator'
-import { buffer } from '@toa.io/generic'
-import { map } from '@toa.io/streams'
-import { formats, types } from './formats'
+import { buffer } from '@toa.io/streams'
+import { formats } from './formats'
 import { BadRequest, NotAcceptable, UnsupportedMediaType } from './exceptions'
-
-export function write (request: Request, response: Response, body: any): void {
-  if (body instanceof Readable) void pipe(body, request, response)
-  else send(body, request, response)
+import type { ParsedQs } from 'qs'
+import type { Format } from './formats'
+
+export function write
+(request: IncomingMessage, response: Response, message: OutgoingMessage): void {
+  if (message.body instanceof Readable)
+    stream(message, request, response)
+  else
+    send(message, request, response)
 }
 
 export async function read (request: Request): Promise<any> {
   const type = request.headers['content-type']
 
-  if (type === undefined) return undefined
+  if (type === undefined)
+    return undefined
 
-  if (!(type in formats)) throw new UnsupportedMediaType()
+  if (!(type in formats))
+    throw new UnsupportedMediaType()
 
   const format = formats[type]
 
@@ -30,48 +35,68 @@ export async function read (request: Request): Promise<any> {
   }
 }
 
-function send (body: any, request: Request, response: Response): void {
-  if (body === undefined || body?.length === 0) {
+function send (message: OutgoingMessage, request: IncomingMessage, response: Response): void {
+  if (message.body === undefined) {
     response.end()
 
     return
   }
 
-  const type = negotiate(request)
-  const format = formats[type]
-  const buf = format.encode(body)
+  if (request.encoder === null)
+    throw new NotAcceptable()
+
+  const buf = request.encoder.encode(message.body)
 
-  // content-length and etag are set by Express
-  response.set('content-type', type)
-  response.send(buf)
+  response.set('content-type', request.encoder.type)
+  response.end(buf)
 }
 
-async function pipe (stream: Readable, request: Request, response: Response): Promise<void> {
-  const type = negotiate(request)
-  const format = formats[type]
+function stream
+(message: OutgoingMessage, request: IncomingMessage, response: Response): void {
+  const encoded = message.headers !== undefined && 'content-type' in message.headers
+
+  if (encoded)
+    pipe(message, response)
+  else
+    multipart(message, request, response)
 
-  response.set('content-type', type)
-  map(stream, format.encode).pipe(response)
+  message.body.on('error', (e: Error) => {
+    console.error(e)
+    response.end()
+  })
 }
 
-function negotiate (request: Request): string {
-  const negotiator = new Negotiator(request)
-  const mediaType = negotiator.mediaType(types)
+function pipe (message: OutgoingMessage, response: Response): void {
+  response.set(message.headers)
+  message.body.pipe(response)
+}
 
-  if (mediaType === undefined) throw new NotAcceptable()
+function multipart (message: OutgoingMessage, request: IncomingMessage, response: Response): void {
+  if (request.encoder === null)
+    throw new NotAcceptable()
 
-  return mediaType
-}
+  const encoder = request.encoder
 
-interface Message {
-  body: any
+  response.set('content-type', `${encoder.multipart}; boundary=${BOUNDARY}`)
+
+  message.body
+    .map((part: unknown) => Buffer.concat([CUT, encoder.encode(part)]))
+    .on('end', () => response.end(FINALCUT))
+    .pipe(response)
 }
 
-export interface IncomingMessage extends Message {
+const BOUNDARY = 'cut'
+const CUT = Buffer.from(`--${BOUNDARY}\r\n`)
+const FINALCUT = Buffer.from(`--${BOUNDARY}--`)
+
+export interface IncomingMessage extends Request {
   method: string
   path: string
+  url: string
   headers: IncomingHttpHeaders
   query: Query
+  parse: <T> () => Promise<T>
+  encoder: Format | null
 }
 
 export interface OutgoingMessage {
@@ -80,7 +105,7 @@ export interface OutgoingMessage {
   body?: any
 }
 
-export interface Query {
+export interface Query extends ParsedQs {
   id?: string
   criteria?: string
   sort?: string

package/source/RTD/Route.ts

@@ -25,7 +25,7 @@ export class Route {
       if (segment.fragment !== null && segment.fragment !== fragments[i])
         return null
 
-      if (segment.fragment === null)
+      if (segment.fragment === null && segment.placeholder !== null)
         parameters.push({ name: segment.placeholder, value: fragments[i] })
     }
 

package/source/RTD/segment.ts

@@ -14,6 +14,7 @@ export function fragment (path: string): string[] {
 
 function parse (segment: string): Segment {
   if (segment[0] === ':') return { fragment: null, placeholder: segment.substring(1) }
+  else if (segment === '*') return { fragment: null, placeholder: null }
   else return { fragment: segment }
 }
 
@@ -21,5 +22,5 @@ export type Segment = {
   fragment: string
 } | {
   fragment: null
-  placeholder: string
+  placeholder: string | null
 }