@toa.io/extensions.exposition 1.0.0-alpha.3 → 1.0.0-alpha.300

package/source/directives/octets/schemas.test.ts

@@ -1,21 +0,0 @@
-import * as schemas from './schemas'
-
-describe('workflow', () => {
-  const ok = [
-    { echo: 'hello world' },
-    [{ echo: 'hello world' }, { ok: 'ok' }]
-  ]
-
-  const oh = [
-    { echo: [] },
-    { echo: 'hello world', ok: { not: 'ok' } }
-  ]
-
-  it.each(ok)('should be valid', (workflow) => {
-    expect(() => schemas.workflow.validate(workflow)).not.toThrow()
-  })
-
-  it.each(oh)('should not be valid', (workflow) => {
-    expect(() => schemas.workflow.validate(workflow)).toThrow()
-  })
-})

package/source/directives/octets/schemas.ts

@@ -1,19 +0,0 @@
-import { resolve } from 'node:path'
-import schemas from '@toa.io/schemas'
-import type { Permissions as FetchPermissions } from './Fetch'
-import type { Permissions as ListPermissions } from './List'
-import type { Options as StoreOptions } from './Store'
-import type { Options as DeleteOptions } from './Delete'
-import type { Schema } from '@toa.io/schemas'
-import type { Unit } from './workflows'
-
-const path = resolve(__dirname, '../../../schemas/octets')
-const namespace = schemas.namespace(path)
-
-export const context: Schema<string> = namespace.schema('context')
-export const store: Schema<StoreOptions | null> = namespace.schema('store')
-export const fetch: Schema<FetchPermissions | null> = namespace.schema('fetch')
-export const remove: Schema<DeleteOptions | null> = namespace.schema('delete')
-export const list: Schema<ListPermissions | null> = namespace.schema('list')
-export const permute: Schema<null> = namespace.schema('permute')
-export const workflow: Schema<Unit[] | Unit> = namespace.schema('workflow')

package/source/directives/octets/types.ts

@@ -1,14 +0,0 @@
-import type { Parameter } from '../../RTD'
-import type * as io from '../../io'
-
-export interface Directive {
-  readonly targeted: boolean
-
-  apply: (storage: string, input: Input, parameters: Parameter[]) => io.Output | Promise<io.Output>
-}
-
-export interface Extension {
-  octets?: string
-}
-
-export type Input = io.Input & Extension

package/source/directives/octets/workflows/Execution.ts

@@ -1,76 +0,0 @@
-import { Readable } from 'stream'
-import type { Unit } from './Workflow'
-import type { Remotes } from '../../../Remotes'
-import type { Component } from '@toa.io/core'
-import type { Maybe } from '@toa.io/types'
-import type { Entry } from '@toa.io/extensions.storages'
-
-export class Execution extends Readable {
-  private readonly units: Unit[]
-  private readonly remotes: Remotes
-  private readonly context: Context
-  private readonly components: Record<string, Component> = {}
-  private readonly discovery: Record<string, Promise<Component>> = {}
-  private interrupted = false
-
-  public constructor (context: Context, units: Unit[], remotes: Remotes) {
-    super({ objectMode: true })
-
-    this.context = context
-    this.units = units
-    this.remotes = remotes
-
-    void this.run()
-  }
-
-  public override _read (): void {
-  }
-
-  private async run (): Promise<void> {
-    for (const unit of this.units) {
-      await this.execute(unit)
-
-      if (this.interrupted)
-        break
-    }
-
-    this.push(null)
-  }
-
-  private async execute (unit: Unit): Promise<void> {
-    const promises = Object.entries(unit).map(async ([step, endpoint]) => {
-      const result = await this.call(endpoint).catch((error: Error) => console.error(error))
-
-      if (result instanceof Error) {
-        this.push({ error: { step, ...result } })
-        this.interrupted = true
-      } else
-        this.push({ [step]: result ?? null })
-    })
-
-    await Promise.all(promises)
-  }
-
-  private async call (endpoint: string): Promise<Maybe<unknown>> {
-    const [operation, component, namespace = 'default'] = endpoint.split('.').reverse()
-    const key = `${namespace}.${component}`
-
-    this.components[key] ??= await this.discover(key, namespace, component)
-
-    return await this.components[key].invoke(operation, { input: this.context })
-  }
-
-  private async discover (key: string, namespace: string, component: string): Promise<Component> {
-    if (this.discovery[key] === undefined)
-      this.discovery[key] = this.remotes.discover(namespace, component)
-
-    return await this.discovery[key]
-  }
-}
-
-export interface Context {
-  storage: string
-  path: string
-  entry: Entry
-  parameters: Record<string, string>
-}

package/source/directives/octets/workflows/Workflow.ts

@@ -1,37 +0,0 @@
-import { posix } from 'node:path'
-import { match } from 'matchacho'
-import { Execution } from './Execution'
-import type { Context } from './Execution'
-import type { Parameter } from '../../../RTD'
-import type { Input } from '../types'
-import type { Entry } from '@toa.io/extensions.storages'
-import type { Remotes } from '../../../Remotes'
-
-export class Workflow {
-  private readonly units: Unit[]
-  private readonly remotes: Remotes
-
-  public constructor (units: Unit[] | Unit, remotes: Remotes) {
-    this.units = match<Unit[]>(units,
-      Array, (units: Unit[]) => units,
-      Object, (unit: Unit) => [unit])
-
-    this.remotes = remotes
-  }
-
-  // eslint-disable-next-line max-params
-  public execute
-  (request: Input, storage: string, entry: Entry, params: Parameter[]): Execution {
-    const path = posix.join(request.path, entry.id)
-    const parameters: Record<string, string> = {}
-
-    for (const { name, value } of params)
-      parameters[name] = value
-
-    const context: Context = { storage, path, entry, parameters }
-
-    return new Execution(context, this.units, this.remotes)
-  }
-}
-
-export type Unit = Record<string, string>

package/source/directives/octets/workflows/index.ts

@@ -1 +0,0 @@
-export { Workflow, type Unit } from './Workflow'

package/source/directives/vary/Directive.ts

@@ -1,6 +0,0 @@
-import type { Properties } from './Properties'
-import type { Input } from '../../io'
-
-export interface Directive {
-  preflight: (request: Input, properties: Properties) => void
-}

package/source/directives/vary/Embed.ts

@@ -1,62 +0,0 @@
-import assert from 'node:assert'
-import { Header, embeddings } from './embeddings'
-import type { Embedding } from './embeddings'
-import type { Input } from '../../io'
-import type { Directive } from './Directive'
-import type { Properties } from './Properties'
-
-export class Embed implements Directive {
-  private readonly embeddings: Array<[string, Embedding[]]> = []
-
-  public constructor (map: Record<string, string | string[]>) {
-    for (const [key, values] of Object.entries(map)) {
-      const names = Array.isArray(values) ? values : [values]
-
-      const instances = names.map((name) => {
-        if (name[0] === ':')
-          return new Header(name.slice(1))
-
-        assert.ok(name in embeddings, `Unknown embedding: ${name}`)
-
-        return new embeddings[name]()
-      })
-
-      this.embeddings.push([key, instances])
-    }
-  }
-
-  public preflight (input: Input, properties: Properties): void {
-    const values: Record<string, unknown> = {}
-
-    for (const [key, instances] of this.embeddings)
-      values[key] = this.resolve(instances, input, properties)
-
-    input.pipelines.body.push(this.embedding(values))
-  }
-
-  private resolve (instances: Embedding[], input: Input, properties: Properties): unknown {
-    let value
-
-    for (const instance of instances) {
-      value = instance.resolve(input, properties)
-
-      if (value !== undefined)
-        break
-    }
-
-    assert.ok(value !== undefined, 'Neither embedding resolved a value.')
-
-    return value
-  }
-
-  private embedding (values: Record<string, unknown>) {
-    return (body: unknown): object => {
-      if (body === undefined || body === null || typeof body !== 'object')
-        return values
-
-      Object.assign(body, values)
-
-      return body
-    }
-  }
-}

package/source/directives/vary/Properties.ts

@@ -1,17 +0,0 @@
-export interface Properties {
-  languages?: string[]
-}
-
-export class Property<K extends keyof Properties = keyof Properties> {
-  public readonly name: K
-  public readonly value: Properties[K]
-
-  public constructor (name: K, value: Properties[K]) {
-    this.name = name
-    this.value = value
-  }
-}
-
-export const properties: Properties = {
-  languages: []
-}

package/source/directives/vary/Vary.ts

@@ -1,48 +0,0 @@
-import { match } from 'matchacho'
-import { properties, Property } from './Properties'
-import { Embed } from './Embed'
-import type { Properties } from './Properties'
-import type { Directive } from './Directive'
-import type { Family } from '../../Directive'
-import type { Input, Output } from '../../io'
-
-export class Vary implements Family {
-  public readonly name = 'vary'
-  public readonly mandatory = false
-
-  public create (name: string, value: unknown): Property | Directive {
-    return match(name,
-      () => name in properties, (name: PN) => new Property(name, value as PV),
-      () => name in directives, (name: keyof typeof directives) => new directives[name](value),
-      () => {
-        throw new Error(`Unknown directive 'vary:${name}'`)
-      })
-  }
-
-  public preflight (instances: Array<Directive | Property>, request: Input): Output {
-    /*
-    To stop consructing `properties` object on each request, Directive Families must be refactored
-    from singleton factories to per-Node instances on the Tree.
-     */
-    const properties: Properties = {}
-    const directives: Directive[] = []
-
-    for (const instance of instances)
-      if (instance instanceof Property)
-        properties[instance.name] = instance.value
-      else
-        directives.push(instance)
-
-    for (const directive of directives)
-      directive.preflight(request, properties)
-
-    return null
-  }
-}
-
-type PN = keyof Properties
-type PV = Properties[PN]
-
-const directives: Record<string, new (value: any) => Directive> = {
-  embed: Embed
-}

package/source/directives/vary/embeddings/Embedding.ts

@@ -1,6 +0,0 @@
-import type { Properties } from '../Properties'
-import type { Input } from '../../../io'
-
-export interface Embedding {
-  resolve: (input: Input, properties: Properties) => string | undefined
-}

package/source/directives/vary/embeddings/Header.ts

@@ -1,30 +0,0 @@
-import { cors } from '../../cors'
-import type { Input } from '../../../io'
-import type { Embedding } from './Embedding'
-
-export class Header implements Embedding {
-  private readonly name: string
-
-  public constructor (name: string) {
-    this.name = name
-
-    cors.allowHeader(this.name)
-  }
-
-  public resolve (input: Input): string | undefined {
-    const value = input.headers[this.name]
-
-    if (value === undefined)
-      return value
-
-    input.pipelines.response.push((response) => {
-      response.headers ??= new Headers()
-      response.headers.append('vary', this.name)
-    })
-
-    if (Array.isArray(value))
-      return value.join(', ')
-    else
-      return value
-  }
-}

package/source/directives/vary/embeddings/Language.ts

@@ -1,31 +0,0 @@
-import assert from 'node:assert'
-import Negotiator from 'negotiator'
-import { cors } from '../../cors'
-import type { Properties } from '../Properties'
-import type { Embedding } from './Embedding'
-import type { Input } from '../../../io'
-
-export class Language implements Embedding {
-  public constructor () {
-    cors.allowHeader('accept-language')
-  }
-
-  public resolve (input: Input, properties: Properties): string | undefined {
-    assert.ok(properties.languages !== undefined,
-      'Supported languages are not defined. Use `vary:languages` directive.')
-
-    assert.ok(properties.languages.length > 0,
-      'List of supported languages is empty.')
-
-    const negotiator = new Negotiator(input)
-    const language = negotiator.language(properties.languages) ?? properties.languages[0]
-
-    input.pipelines.response.push((response) => {
-      response.headers ??= new Headers()
-      response.headers.set('content-language', language)
-      response.headers.append('vary', 'accept-language')
-    })
-
-    return language
-  }
-}

package/source/directives/vary/embeddings/index.ts

@@ -1,11 +0,0 @@
-import { Language } from './Language'
-import { Header } from './Header'
-
-import type { Embedding } from './Embedding'
-
-export const embeddings: Record<string, new () => Embedding> = {
-  language: Language
-}
-
-export { Header }
-export type { Embedding }

package/source/directives/vary/index.ts

@@ -1,3 +0,0 @@
-import { Vary } from './Vary'
-
-export const vary = new Vary()

package/source/discovery.ts

@@ -1 +0,0 @@
-export type Label = 'ping' | 'expose'

package/source/exceptions.ts

@@ -1,17 +0,0 @@
-import { type Exception } from '@toa.io/core'
-import * as http from './HTTP'
-
-export function rethrow (exception: Exception): void {
-  // see /runtime/core/src/exceptions.js
-
-  if ((exception.code >= 200 && exception.code < 210) || exception.code === 221)
-    throw new http.BadRequest(exception.message)
-
-  if (exception.code === 302)
-    throw new http.NotFound()
-
-  if (exception.code === 303)
-    throw new http.PreconditionFailed()
-
-  throw exception as unknown as Error
-}

package/source/index.test.ts

@@ -1,9 +0,0 @@
-/**
- * WebStorm can't find jest types if they are in the root of the project,
- * while a current project has its own node_modules.
- *
- * Importing jest here fixes the issue.
- */
-import 'jest'
-
-it.skip('', () => undefined) // prevent jest from complaining about missing tests

package/source/index.ts

@@ -1,6 +0,0 @@
-export { manifest } from './manifest'
-export { deployment } from './deployment'
-export { components } from './Composition'
-export { Factory } from './Factory'
-
-export type { Remotes } from './Remotes'

package/source/io.ts

@@ -1,4 +0,0 @@
-import type { IncomingMessage, OutgoingMessage } from './HTTP'
-
-export type Input = IncomingMessage
-export type Output = OutgoingMessage | null

package/source/manifest.test.ts

@@ -1,51 +0,0 @@
-import { type Manifest } from '@toa.io/norm'
-import { generate } from 'randomstring'
-import { manifest } from './manifest'
-
-const name = 'cm-' + generate()
-const namespace = 'ns' + generate()
-
-let mf: Manifest
-
-const operations = { observe: {} }
-
-beforeEach(() => {
-  mf = { namespace, name, operations } as unknown as Manifest
-})
-
-const declaration = {
-  '/': { GET: 'observe' }
-}
-
-it('should create branch', async () => {
-  const node = manifest(declaration, mf)
-
-  expect(node).toBeDefined()
-  expect(node.routes).toHaveLength(1)
-  expect(node.routes[0].path).toBe('/' + namespace + '/' + name)
-})
-
-it('should not create node for default namespace', async () => {
-  mf.namespace = 'default'
-
-  const node = manifest(declaration, mf)
-
-  expect(node.routes).toHaveLength(1)
-  expect(node.routes[0].path).toBe('/' + name)
-})
-
-it('should throw on invalid declaration type', async () => {
-  expect(() => manifest('hello' as unknown as object, mf))
-    .toThrow('Exposition declaration must be an object')
-})
-
-it('should set namespace and component', async () => {
-  const node = manifest(declaration, mf)
-
-  const root = node.routes[0].node
-  const intemediate = root.routes[0].node
-  const GET = intemediate.methods[0]
-
-  expect(GET.mapping?.namespace).toBe(namespace)
-  expect(GET.mapping?.component).toBe(name)
-})

package/source/manifest.ts

@@ -1,51 +0,0 @@
-import assert from 'node:assert'
-import { parse, type Node, type Method, type Query } from './RTD/syntax'
-import { shortcuts } from './Directive'
-import * as schemas from './schemas'
-import type { Manifest } from '@toa.io/norm'
-
-export function manifest (declaration: object, manifest: Manifest): Node {
-  assert.ok(typeof declaration === 'object' && declaration !== null,
-    'Exposition declaration must be an object')
-
-  declaration = wrap(declaration, manifest.namespace, manifest.name)
-
-  const node = parse(declaration, shortcuts)
-
-  concretize(node, manifest)
-  schemas.node.validate(node)
-
-  return node
-}
-
-function wrap (declaration: object, namespace: string, name: string): object {
-  const path = (namespace === undefined || namespace === 'default' ? '' : '/' + namespace) +
-    '/' + name
-
-  return { [path]: { protected: true, ...declaration } }
-}
-
-function concretize (node: Node, manifest: Manifest): void {
-  for (const route of node.routes) {
-    for (const method of route.node.methods)
-      concretizeMethod(method, manifest)
-
-    concretize(route.node, manifest)
-  }
-}
-
-function concretizeMethod (method: Method, manifest: Manifest): void {
-  if (method.mapping === undefined)
-    return
-
-  const operation = manifest.operations[method.mapping.endpoint]
-
-  if (operation === undefined)
-    throw new Error(`Operation '${method.mapping.endpoint}' not found`)
-
-  if (method.mapping.query === undefined && operation.query !== false)
-    method.mapping.query = {} as unknown as Query // schema will substitute default values
-
-  method.mapping.namespace = manifest.namespace
-  method.mapping.component = manifest.name
-}

package/source/root.ts

@@ -1,38 +0,0 @@
-import { decode, merge } from '@toa.io/generic'
-import { syntax } from './RTD'
-
-export function resolve (): syntax.Node {
-  const value = process.env.TOA_EXPOSITION
-  const root = value !== undefined ? decode<syntax.Node>(value) : syntax.createNode()
-
-  merge(root, PREDEFINED)
-
-  return root
-}
-
-const PREDEFINED: syntax.Node = {
-  routes: [
-    {
-      path: '/identity',
-      node: {
-        isolated: true,
-        routes: [],
-        methods: [
-          {
-            verb: 'GET',
-            directives: [
-              {
-                family: 'auth',
-                name: 'echo',
-                value: null
-              }
-            ]
-          }
-        ],
-        directives: []
-      }
-    }
-  ],
-  methods: [],
-  directives: []
-}

package/source/schemas.ts

@@ -1,13 +0,0 @@
-import { resolve } from 'node:path'
-import schemas from '@toa.io/schemas'
-import type { Query } from './HTTP'
-import type { Node } from './RTD'
-import type { Schema } from '@toa.io/schemas'
-import type { Annotation } from './Annotation'
-
-const path = resolve(__dirname, '../schemas')
-const namespace = schemas.namespace(path)
-
-export const querystring: Schema<Query> = namespace.schema('querystring')
-export const annotaion: Schema<Annotation> = namespace.schema('annotation')
-export const node: Schema<Node> = namespace.schema('node')

package/transpiled/Annotation.d.ts

@@ -1,7 +0,0 @@
-export interface Annotation {
-    host?: string;
-    class?: string;
-    annotations?: Record<string, string>;
-    debug: boolean;
-    '/'?: object;
-}

package/transpiled/Annotation.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=Annotation.js.map

package/transpiled/Annotation.js.map

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

package/transpiled/HTTP/Server.fixtures.d.ts

@@ -1,10 +0,0 @@
-/// <reference types="node" />
-/// <reference types="jest" />
-import type { IncomingMessage } from './messages';
-import type { NextFunction, Response, Express, Request } from 'express';
-import type { CorsOptions } from 'cors';
-export declare function createRequest(req?: Partial<Request>, content?: string | Buffer): jest.MockedObject<IncomingMessage>;
-export declare const res: jest.MockedObject<Response<any, Record<string, any>>>;
-export declare const next: NextFunction;
-export declare const express: jest.Mock<jest.Mock<Express, any, any>, [], any>;
-export declare const cors: jest.Mock<() => undefined, [_: CorsOptions], any>;

package/transpiled/HTTP/Server.fixtures.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cors = exports.express = exports.next = exports.res = exports.createRequest = void 0;
-const stream_1 = require("stream");
-const server = {
-    close: jest.fn()
-};
-const app = {
-    enable: jest.fn(),
-    disable: jest.fn(),
-    use: jest.fn(),
-    listen: jest.fn(() => server)
-};
-function createRequest(req = {}, content = '') {
-    const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
-    const stream = stream_1.Readable.from(buffer);
-    Object.assign(stream, { headers: {} }, req);
-    return stream;
-}
-exports.createRequest = createRequest;
-exports.res = {
-    status: jest.fn(() => exports.res),
-    sendStatus: jest.fn(() => exports.res),
-    set: jest.fn(() => exports.res),
-    send: jest.fn(() => exports.res),
-    end: jest.fn(() => exports.res)
-};
-exports.next = jest.fn();
-exports.express = jest.fn(() => app);
-exports.cors = jest.fn((_) => () => undefined);
-//# sourceMappingURL=Server.fixtures.js.map

package/transpiled/HTTP/Server.fixtures.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Server.fixtures.js","sourceRoot":"","sources":["../../source/HTTP/Server.fixtures.ts"],"names":[],"mappings":";;;AAAA,mCAAiC;AAMjC,MAAM,MAAM,GAAG;IACb,KAAK,EAAE,IAAI,CAAC,EAAE,EAAE;CACoB,CAAA;AAEtC,MAAM,GAAG,GAAG;IACV,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE;IACjB,OAAO,EAAE,IAAI,CAAC,EAAE,EAAE;IAClB,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE;IACd,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC;CACG,CAAA;AAElC,SAAgB,aAAa,CAAE,MAAwB,EAAE,EAAE,UAA2B,EAAE;IAEtF,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACxE,MAAM,MAAM,GAAG,iBAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IAEpC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,CAAA;IAE3C,OAAO,MAAuD,CAAA;AAChE,CAAC;AARD,sCAQC;AAEY,QAAA,GAAG,GAAG;IACjB,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,WAAG,CAAC;IAC1B,UAAU,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,WAAG,CAAC;IAC9B,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,WAAG,CAAC;IACvB,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,WAAG,CAAC;IACxB,GAAG,EAAE,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,WAAG,CAAC;CACkB,CAAA;AAE9B,QAAA,IAAI,GAAG,IAAI,CAAC,EAAE,EAA6B,CAAA;AAE3C,QAAA,OAAO,GAAG,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAA;AAE5B,QAAA,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAc,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAA"}