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

package/source/RTD/Route.ts

@@ -1,59 +0,0 @@
-import { type Node } from './Node'
-import { type Segment } from './segment'
-import { type Match, type Parameter } from './Match'
-
-export class Route {
-  public readonly root: boolean
-  public readonly variables: number = 0
-  private readonly segments: Segment[]
-  private readonly node: Node
-
-  public constructor (segments: Segment[], node: Node) {
-    this.root = segments.length === 0
-    this.segments = segments
-    this.node = node
-
-    for (const segment of segments)
-      if (segment.fragment === null)
-        this.variables++
-  }
-
-  public match (fragments: string[], parameters: Parameter[]): Match | null {
-    for (let i = 0; i < this.segments.length; i++) {
-      const segment = this.segments[i]
-
-      if (segment.fragment !== null && segment.fragment !== fragments[i])
-        return null
-
-      if (segment.fragment === null && segment.placeholder !== null)
-        parameters.push({ name: segment.placeholder, value: fragments[i] })
-    }
-
-    const exact = this.segments.length === fragments.length
-
-    if (exact && !this.node.intermediate) return { node: this.node, parameters }
-    else return this.matchNested(fragments, parameters)
-  }
-
-  public equals (route: Route): boolean {
-    if (route.segments.length !== this.segments.length)
-      return false
-
-    for (let i = 0; i < this.segments.length; i++)
-      if (this.segments[i].fragment !== route.segments[i].fragment)
-        return false
-
-    return true
-  }
-
-  public merge (route: Route): void {
-    this.node.merge(route.node)
-  }
-
-  private matchNested (fragments: string[], parameters: Parameter[]): Match | null {
-    fragments = fragments.slice(this.segments.length)
-    parameters = parameters.slice()
-
-    return this.node.match(fragments, parameters)
-  }
-}

package/source/RTD/Tree.ts

@@ -1,57 +0,0 @@
-import { type Node } from './Node'
-import { createNode } from './factory'
-import { fragment } from './segment'
-import { type Match } from './Match'
-import { type Context } from './Context'
-import { type Directives, type DirectivesFactory } from './Directives'
-import { type Endpoint, type EndpointsFactory } from './Endpoint'
-import type * as syntax from './syntax'
-
-export class Tree<
-  TEndpoint extends Endpoint<TEndpoint> = any,
-  TDirectives extends Directives<TDirectives> = any
-> {
-  private readonly root: syntax.Node
-  private readonly trunk: Node<TEndpoint, TDirectives>
-  private readonly endpoints: EndpointsFactory<TEndpoint>
-  private readonly directives: DirectivesFactory
-
-  public constructor
-  (node: syntax.Node, endpoints: EndpointsFactory, directives: DirectivesFactory) {
-    this.endpoints = endpoints
-    this.directives = directives
-    this.trunk = this.createNode(node, PROTECTED)
-    this.root = node
-  }
-
-  public match (path: string): Match<TEndpoint, TDirectives> | null {
-    if (path === '/')
-      return { node: this.trunk, parameters: [] }
-
-    const fragments = fragment(path)
-
-    return this.trunk.match(fragments)
-  }
-
-  public merge (node: syntax.Node, extension: any): void {
-    const branch = this.createNode(node, !PROTECTED, extension)
-
-    this.trunk.merge(branch)
-  }
-
-  private createNode (node: syntax.Node, protect: boolean, extension?: any): Node {
-    const context: Context = {
-      protected: protect,
-      endpoints: this.endpoints,
-      directives: {
-        factory: this.directives,
-        stack: this.root?.directives ?? []
-      },
-      extension
-    }
-
-    return createNode(node, context)
-  }
-}
-
-const PROTECTED = true

package/source/RTD/factory.ts

@@ -1,47 +0,0 @@
-import { Node, type Properties } from './Node'
-import { Route } from './Route'
-import { type Context } from './Context'
-import { segment } from './segment'
-import { Method, type Methods } from './Method'
-import { type Endpoint } from './Endpoint'
-import { type Directives } from './Directives'
-import type * as syntax from './syntax'
-
-export function createNode<TEndpoint extends Endpoint, TDirectives extends Directives>
-(node: syntax.Node, context: Context): Node<TEndpoint, TDirectives> {
-  if (node.isolated === true)
-    context.directives.stack = node.directives
-  else
-    context.directives.stack = node.directives.concat(context.directives.stack)
-
-  const routes: Route[] = node.routes.map((route) => createRoute(route, context))
-  const methods: Methods = {}
-
-  for (const method of node.methods)
-    methods[method.verb] = createMethod(method, context)
-
-  const properties: Properties = { protected: node.protected ?? context.protected }
-
-  return new Node(routes, methods, properties)
-}
-
-function createRoute (route: syntax.Route, context: Context): Route {
-  const stack = context.directives.stack.slice()
-  const segments = segment(route.path)
-  const node = createNode(route.node, context)
-
-  context.directives.stack = stack // restore
-
-  return new Route(segments, node)
-}
-
-function createMethod (method: syntax.Method, context: Context): Method {
-  const stack = context.directives.stack.concat(method.directives.reverse())
-  const directives = context.directives.factory.create(stack)
-
-  const endpoint = method.mapping?.endpoint === undefined
-    ? null
-    : context.endpoints.create(method, context)
-
-  return new Method(endpoint, directives)
-}

package/source/RTD/index.ts

@@ -1,8 +0,0 @@
-export * from './Tree'
-export * from './Node'
-export * from './Match'
-export * from './Method'
-export * from './Context'
-export * from './Endpoint'
-export * from './Directives'
-export * as syntax from './syntax'

package/source/RTD/segment.test.ts

@@ -1,32 +0,0 @@
-import { segment, fragment } from './segment'
-
-it('should return segments', async () => {
-  const segments = segment('/foo/bar/')
-
-  expect(segments).toHaveLength(2)
-  expect(segments[0].fragment).toBe('foo')
-  expect(segments[1].fragment).toBe('bar')
-})
-
-it('should parse placeholders', async () => {
-  const segments = segment('/foo/:id/')
-
-  expect(segments).toHaveLength(2)
-  expect(segments[0].fragment).toBe('foo')
-  expect(segments[1].fragment).toBeNull()
-
-  // helping typescript
-  if (segments[1].fragment !== null) throw new Error('?')
-
-  expect(segments[1].placeholder).toBe('id')
-})
-
-it('should handle root path', async () => {
-  expect(segment('/')).toStrictEqual([])
-})
-
-it('should split', async () => {
-  const parts = fragment('/foo/bar/')
-
-  expect(parts).toStrictEqual(['foo', 'bar'])
-})

package/source/RTD/segment.ts

@@ -1,26 +0,0 @@
-export function segment (path: string): Segment[] {
-  return fragment(path).map(parse)
-}
-
-export function fragment (path: string): string[] {
-  const parts = path.split('/')
-
-  // trailing slash
-  if (parts[parts.length - 1] === '') parts.length--
-
-  // leading slash
-  return parts.splice(1)
-}
-
-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 }
-}
-
-export type Segment = {
-  fragment: string
-} | {
-  fragment: null
-  placeholder: string | null
-}

package/source/RTD/syntax/index.ts

@@ -1,2 +0,0 @@
-export * from './parse'
-export * from './types'

package/source/RTD/syntax/parse.test.ts

@@ -1,188 +0,0 @@
-import { parse } from './parse'
-
-describe('routes', () => {
-  it('should parse route', async () => {
-    const declaration = {
-      '/': {},
-      '/foo': {}
-    }
-
-    const node = parse(declaration)
-
-    expect(node.routes).toHaveLength(2)
-    expect(node.routes[0].path).toBe('/')
-    expect(node.routes[1].path).toBe('/foo')
-  })
-
-  it('should parse nested routes', async () => {
-    const declaration = {
-      '/': {
-        '/foo': {},
-        '/bar': {}
-      }
-    }
-
-    const node = parse(declaration)
-    const root = node.routes[0].node
-
-    expect(root.routes).toHaveLength(2)
-    expect(root.routes[0].path).toBe('/foo')
-    expect(root.routes[1].path).toBe('/bar')
-  })
-})
-
-describe('methods', () => {
-  it('should parse methods', () => {
-    const declaration = {
-      '/': {
-        GET: {
-          endpoint: 'observe'
-        }
-      }
-    }
-
-    const node = parse(declaration)
-    const root = node.routes[0].node
-
-    expect(root.methods).toHaveLength(1)
-    expect(root.methods[0].verb).toBe('GET')
-    expect(root.methods[0].mapping).toMatchObject({ endpoint: 'observe' })
-  })
-
-  it('should parse endpoint shortcut', async () => {
-    const declaration = {
-      '/': {
-        GET: 'observe'
-      }
-    }
-
-    const node = parse(declaration)
-    const root = node.routes[0].node
-
-    expect(root.methods).toHaveLength(1)
-    expect(root.methods[0].verb).toBe('GET')
-    expect(root.methods[0].mapping).toMatchObject({ endpoint: 'observe' })
-  })
-
-  it('should parse fq endpoint', async () => {
-    const declaration = {
-      '/': {
-        GET: 'dummies.dummy.observe'
-      }
-    }
-
-    const node = parse(declaration)
-    const root = node.routes[0].node
-
-    expect(root.methods).toHaveLength(1)
-    expect(root.methods[0].verb).toBe('GET')
-
-    expect(root.methods[0].mapping).toMatchObject({
-      namespace: 'dummies',
-      component: 'dummy',
-      endpoint: 'observe'
-    })
-  })
-
-  it('should parse fq endpoint within default namespace', async () => {
-    const declaration = {
-      '/': {
-        GET: 'dummy.observe'
-      }
-    }
-
-    const node = parse(declaration)
-    const root = node.routes[0].node
-
-    expect(root.methods).toHaveLength(1)
-    expect(root.methods[0].verb).toBe('GET')
-
-    expect(root.methods[0].mapping).toMatchObject({
-      namespace: 'default',
-      component: 'dummy',
-      endpoint: 'observe'
-    })
-  })
-
-  it('should parse directives', async () => {
-    const declaration = {
-      '/': {
-        GET: {
-          'auth:incept': 'id',
-          endpoint: 'observe'
-        }
-      }
-    }
-
-    const node = parse(declaration)
-    const root = node.routes[0].node
-
-    expect(root.methods[0].directives)
-      .toStrictEqual([{ family: 'auth', name: 'incept', value: 'id' }])
-  })
-})
-
-describe('directives', () => {
-  it('should parse shortcuts', async () => {
-    const declaration = {
-      '/': {
-        foo: 'baz'
-      }
-    }
-
-    const shortcuts = new Map<string, string>([
-      ['foo', 'dev:foo']
-    ])
-
-    const node = parse(declaration, shortcuts)
-    const root = node.routes[0].node
-
-    expect(root.directives).toHaveLength(1)
-    expect(root.directives[0].family).toBe('dev')
-    expect(root.directives[0].name).toBe('foo')
-    expect(root.directives[0].value).toBe('baz')
-  })
-})
-
-describe('validation', () => {
-  it('should throw on unknown key', async () => {
-    const declaration = { hello: 'world' }
-
-    expect(() => parse(declaration)).toThrow('RTD parse error: unknown key \'hello\'.')
-  })
-
-  it('should throw on invalid mapping', async () => {
-    const declaration = {
-      '/': {
-        GET: {
-          endpoint: 'observe',
-          hello: 'world'
-        }
-      }
-    }
-
-    expect(() => parse(declaration)).toThrow('/methods/0/mapping')
-  })
-})
-
-it('should expand ranges', async () => {
-  const declaration = {
-    '/': {
-      GET: {
-        endpoint: 'enumerate',
-        query: {
-          omit: 3,
-          limit: 2
-        }
-      }
-    }
-  }
-
-  const node = parse(declaration)
-  const query = node.routes[0].node.methods[0].mapping?.query
-
-  expect(query).toMatchObject({
-    omit: { value: 3, range: [3, 3] },
-    limit: { value: 2, range: [2, 2] }
-  })
-})

package/source/RTD/syntax/parse.ts

@@ -1,154 +0,0 @@
-import * as schemas from '../../schemas'
-import {
-  verbs,
-  type Node,
-  type Route,
-  type Method,
-  type Mapping,
-  type Directive,
-  type Range
-} from './types'
-
-export function parse (input: object, shortcuts?: Shortcuts): Node {
-  const node = parseNode(input, shortcuts)
-
-  schemas.node.validate(node)
-
-  return node
-}
-
-function parseNode (input: object, shortcuts?: Shortcuts): Node {
-  const node = createNode()
-
-  for (const [key, value] of Object.entries(input)) {
-    if (PROPERTIES.includes(key as keyof Node)) {
-      node[key as keyof Node] = value
-
-      continue
-    }
-
-    if (key[0] === '/') {
-      const route = parseRoute(key, value as Node, shortcuts)
-
-      node.routes.push(route)
-
-      continue
-    }
-
-    if (verbs.has(key)) {
-      const method = parseMethod(key, value as Mapping, shortcuts)
-
-      node.methods.push(method)
-
-      continue
-    }
-
-    const directive = parseDirective(key, value, shortcuts)
-
-    if (directive !== null) {
-      node.directives.push(directive)
-
-      continue
-    }
-
-    throw new Error(`RTD parse error: unknown key '${key}'.`)
-  }
-
-  return node
-}
-
-export function createNode (): Node {
-  return {
-    routes: [],
-    methods: [],
-    directives: []
-  }
-}
-
-function parseRoute (path: string, value: Node, shortcuts?: Shortcuts): Route {
-  const node = parse(value, shortcuts)
-
-  return createRoute(path, node)
-}
-
-function createRoute (path: string, node: Node): Route {
-  return { path, node }
-}
-
-function parseMethod (verb: string, value: Mapping | string, shortcuts?: Shortcuts): Method {
-  const mapping = typeof value === 'string' ? { endpoint: value } : value
-
-  parseEndpoint(mapping)
-  parseQuery(mapping)
-
-  const directives = parseDirectives(mapping, shortcuts)
-
-  return { verb, mapping, directives }
-}
-
-function parseEndpoint (mapping: Mapping): void {
-  if (mapping.endpoint === undefined)
-    return
-
-  const [endpoiont, component, namespace] = mapping.endpoint.split('.').reverse()
-
-  if (component !== undefined) {
-    mapping.component = component
-    mapping.namespace = namespace ?? mapping.namespace ?? 'default'
-    mapping.endpoint = endpoiont
-  }
-}
-
-function parseQuery (mapping: any): void {
-  const query = mapping.query
-
-  if (query === undefined || query === null)
-    return
-
-  if (typeof query.limit === 'number')
-    query.limit = expandRange(query.limit as number)
-
-  if (typeof query.omit === 'number')
-    query.omit = expandRange(query.omit as number)
-}
-
-function parseDirectives (mapping: Record<string, any>, shortcuts?: Shortcuts): Directive[] {
-  const directives: Directive[] = []
-
-  for (const [key, value] of Object.entries(mapping)) {
-    const directive = parseDirective(key, value, shortcuts)
-
-    if (directive === null)
-      continue
-
-    directives.push(directive)
-
-    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-    delete mapping[key]
-  }
-
-  return directives
-}
-
-function parseDirective (key: string, value: any, shortcuts?: Shortcuts): Directive | null {
-  if (shortcuts?.has(key) === true)
-    key = shortcuts.get(key)! // eslint-disable-line @typescript-eslint/no-non-null-assertion
-
-  const match = key.match(DIRECTIVE_RX)
-
-  if (match === null)
-    return null
-
-  const { family, name } = match.groups as { family: string, name: string }
-
-  return { family, name, value }
-}
-
-function expandRange (range: number): Range {
-  return { value: range, range: [range, range] }
-}
-
-const DIRECTIVE_RX = /^(?<family>\w{1,32}):(?<name>\w{1,32})$/
-const PROPERTIES: Array<keyof Node> = ['protected', 'isolated']
-
-export type Shortcuts = Map<string, string>

package/source/RTD/syntax/types.ts

@@ -1,48 +0,0 @@
-export interface Node {
-  protected?: boolean
-  isolated?: boolean
-  routes: Route[]
-  methods: Method[]
-  directives: Directive[]
-}
-
-export interface Route {
-  path: string
-  node: Node
-}
-
-export interface Method {
-  verb: string
-  mapping?: Mapping
-  directives: Directive[]
-}
-
-export interface Directive {
-  family: string
-  name: string
-  value: any
-}
-
-export interface Mapping {
-  namespace?: string
-  component?: string
-  endpoint: string
-  query?: Query
-}
-
-export interface Query {
-  id?: string
-  criteria?: string
-  sort?: string
-  omit: Range
-  limit: Range
-  selectors?: string[]
-  projection?: string[]
-}
-
-export interface Range {
-  value?: number
-  range: [number, number]
-}
-
-export const verbs = new Set<string>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'])

package/source/Remotes.test.ts

@@ -1,42 +0,0 @@
-import { generate } from 'randomstring'
-import { Connector } from '@toa.io/core'
-import { Remotes } from './Remotes'
-import type { Bootloader } from './Factory'
-import type { Locator } from '@toa.io/core'
-
-jest.mock('@toa.io/boot', () => ({
-  remote: async (locator: Locator) => await boot.remote(locator)
-}))
-
-const boot = {
-  remote: jest.fn(async (..._) => ({
-    connect: jest.fn(() => undefined),
-    link: jest.fn(() => undefined)
-  }))
-} as unknown as jest.MockedObjectDeep<Bootloader>
-
-const namespace = generate()
-const name = generate()
-
-let remotes: Remotes
-
-beforeEach(() => {
-  remotes = new Remotes(boot)
-})
-
-it('should create remote', async () => {
-  const remote = await remotes.discover(namespace, name)
-
-  expect(boot.remote).toHaveBeenCalledWith(expect.objectContaining({ namespace, name }))
-  expect(remote).toStrictEqual(await boot.remote.mock.results[0].value)
-})
-
-it('should be instance of Connector', async () => {
-  expect(remotes).toBeInstanceOf(Connector)
-})
-
-it('should depend on created remotes', async () => {
-  const remote = await remotes.discover(namespace, name)
-
-  expect(remote.link).toHaveBeenCalledWith(remotes)
-})

package/source/Remotes.ts

@@ -1,30 +0,0 @@
-import { Locator, Connector, type Component } from '@toa.io/core'
-import { type Bootloader } from './Factory'
-
-export class Remotes extends Connector {
-  private readonly boot: Bootloader
-  private readonly remotes: Record<string, Promise<Component>> = {}
-
-  public constructor (boot: Bootloader) {
-    super()
-    this.boot = boot
-  }
-
-  public async discover (namespace: string, name: string): Promise<Component> {
-    const locator = new Locator(name, namespace)
-
-    this.remotes[locator.id] ??= this.create(locator)
-
-    return await this.remotes[locator.id]
-  }
-
-  private async create (locator: Locator): Promise<Component> {
-    const remote = await this.boot.remote(locator)
-
-    this.depends(remote)
-
-    await remote.connect()
-
-    return remote
-  }
-}