@toa.io/extensions.exposition 0.20.0-dev.8 → 0.20.0

package/source/manifest.test.ts

@@ -0,0 +1,59 @@
+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()
+
+  // namespace route
+  expect(node.routes).toHaveLength(1)
+  expect(node.routes[0].path).toBe('/' + namespace)
+
+  const ns = node.routes[0].node
+
+  // component route
+  expect(ns.routes).toHaveLength(1)
+  expect(ns.routes[0].path).toBe('/' + 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('RTD parse error')
+})
+
+it('should set namespace and component', async () => {
+  const node = manifest(declaration, mf)
+
+  const ns = node.routes[0].node
+  const cm = ns.routes[0].node
+  const root = cm.routes[0].node
+  const GET = root.methods[0]
+
+  expect(GET.mapping?.namespace).toBe(namespace)
+  expect(GET.mapping?.component).toBe(name)
+})

package/source/manifest.ts

@@ -0,0 +1,48 @@
+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 {
+  declaration = wrap(manifest.name, declaration)
+
+  if (manifest.namespace !== undefined && manifest.namespace !== 'default')
+    declaration = wrap(manifest.namespace, declaration)
+
+  const node = parse(declaration, shortcuts)
+
+  concretize(node, manifest)
+
+  schemas.node.validate(node)
+
+  return node
+}
+
+function wrap (segment: string, declaration: object): object {
+  return { ['/' + segment]: { 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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,9 @@
+import { resolve } from 'node:path'
+import schemas from '@toa.io/schemas'
+
+const path = resolve(__dirname, '../schemas')
+const namespace = schemas.namespace(path)
+
+export const querystring = namespace.schema('querystring')
+export const annotaion = namespace.schema('annotation')
+export const node = namespace.schema('node')

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./transpiled"
+  },
+  "include": [
+    "source"
+  ],
+  "exclude": [
+    "**/*.test.ts"
+  ]
+}

package/src/.manifest/index.js

@@ -1,7 +0,0 @@
-'use strict'
-
-const { normalize } = require('./normalize')
-const { validate } = require('./validate')
-
-exports.normalize = normalize
-exports.validate = validate

package/src/.manifest/normalize.js

@@ -1,58 +0,0 @@
-'use strict'
-
-/**
- * @returns {toa.extensions.exposition.declarations.Node}
- */
-const normalize = (node, manifest) => {
-  if (node instanceof Array) node = { operations: node }
-
-  node.operations = operations(node.operations, manifest)
-  node.query = query(node.query)
-
-  for (const [key, value] of Object.entries(node)) {
-    if (key.substring(0, 1) === '/') node[key] = normalize(value, manifest)
-  }
-
-  return node
-}
-
-/**
- * @returns {toa.extensions.exposition.declarations.Operation[] | undefined}
- */
-const operations = (operations, manifest) => {
-  if (operations === undefined) return
-
-  return operations.map((operation) => {
-    if (typeof operation === 'object') operation = operation.operation
-
-    if (manifest.operations[operation] === undefined) {
-      throw new Error(`Resource references undefined operation '${operation}'`)
-    }
-
-    const { type, scope, query } = manifest.operations[operation]
-    const normal = { operation, type, scope }
-
-    if (query !== undefined) normal.query = query
-
-    return normal
-  })
-}
-
-/**
- * @returns {toa.extensions.exposition.declarations.Query | undefined}
- */
-const query = (query) => {
-  if (query === undefined) return
-
-  if (query.omit !== undefined && typeof query.omit !== 'object') {
-    query.omit = { value: query.omit, range: [] }
-  }
-
-  if (query.limit !== undefined && typeof query.limit !== 'object') {
-    query.limit = { value: query.limit, range: [] }
-  }
-
-  return query
-}
-
-exports.normalize = normalize

package/src/.manifest/schema.yaml

@@ -1,71 +0,0 @@
-$schema: https://json-schema.org/draft/2019-09/schema
-$id: https://schemas.toa.io/0.0.0/rtd
-
-definitions:
-  resource:
-    type: 'object'
-    patternProperties:
-      ^(\/([^\/#\?]+)?)+\/?$:
-        $ref: "#/definitions/resource"
-    properties:
-      query:
-        type: object
-        properties:
-          criteria:
-            nullable: true
-            type: string
-            minLength: 1
-          sort:
-            type: array
-            uniqueItems: true
-            minItems: 1
-            items:
-              type: string
-          projection:
-            type: array
-            uniqueItems: true
-            minItems: 1
-            items:
-              type: string
-          omit:
-            $ref: "#/definitions/range"
-          limit:
-            $ref: "#/definitions/range"
-        additionalProperties: false
-      operations:
-        type: array
-        uniqueItems: true
-        minItems: 1
-        items:
-          type: object
-          properties:
-            operation:
-              $ref: definitions#/definitions/token
-            type:
-              enum: [ transition, observation, assignment, computation, effect ]
-            scope:
-              type: string
-              enum: [ object, objects, changeset, none ]
-            query:
-              type: boolean
-          additionalProperties: false
-    additionalProperties: false
-  range:
-    type: object
-    properties:
-      value:
-        type: integer
-        minimum: 0
-      range:
-        type: array
-        uniqueItems: true
-        minItems: 0
-        items:
-          $ref: "#/definitions/range/properties/value"
-      additionalProperties: false
-    required: [ range ]
-
-$ref: "#/definitions/resource"
-not:
-  type: object
-  required: [ operations ] # root doesn't have path

package/src/.manifest/validate.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const path = require('path')
-
-const { Schema } = require('@toa.io/schema')
-const { load } = require('@toa.io/yaml')
-
-const schema = load.sync(path.resolve(__dirname, 'schema.yaml'))
-const validator = new Schema(schema)
-
-const validate = (declaration) => {
-  const error = validator.fit(declaration)
-
-  if (error) throw new Error(error.message)
-}
-
-exports.validate = validate

package/src/constants.js

@@ -1,3 +0,0 @@
-'use strict'
-
-exports.PORT = 8000

package/src/deployment.js

@@ -1,23 +0,0 @@
-'use strict'
-
-const { PORT } = require('./constants')
-
-/**
- * @param {toa.norm.context.dependencies.Instance[]} components
- * @param {toa.extensions.exposition.Annotations} annotations
- * @type {toa.deployment.dependency.Constructor}
- */
-const deployment = (components, annotations) => {
-  const group = 'exposition'
-  const name = 'resources'
-  const version = require('../package.json').version
-  const port = PORT
-  const ingress = annotations
-
-  /** @type {toa.deployment.dependency.Service} */
-  const exposition = { group, name, version, port, ingress }
-
-  return { services: [exposition] }
-}
-
-exports.deployment = deployment

package/src/exposition.js

@@ -1,68 +0,0 @@
-'use strict'
-
-const { Connector } = require('@toa.io/core')
-const { console } = require('@toa.io/console')
-
-class Exposition extends Connector {
-  /** @type {toa.core.bindings.Broadcast} */
-  #broadcast
-
-  /** @type {toa.extensions.exposition.remotes.Factory} */
-  #remote
-
-  /** @type {toa.extensions.exposition.exposition.Remotes} */
-  #remotes = {}
-
-  /**
-   * @param {toa.core.bindings.Broadcast} broadcast
-   * @param {toa.extensions.exposition.remotes.Factory} connect
-   */
-  constructor (broadcast, connect) {
-    super()
-
-    this.#broadcast = broadcast
-    this.#remote = connect
-
-    this.depends(broadcast)
-  }
-
-  /** @override */
-  async open () {
-    await this.#broadcast.receive('expose', this.#expose.bind(this))
-    this.#broadcast.transmit('ping', {}).then()
-
-    console.info(this.constructor.name + ' started')
-  }
-
-  /**
-   * @param {toa.extensions.exposition.declarations.Exposition} declaration
-   * @returns {Promise<void>}
-   */
-  async #expose (declaration) {
-    const { namespace, name, resources } = declaration
-    const key = namespace + '/' + name
-
-    if (this.#remotes[key] === undefined) this.#remotes[key] = this.#connect(namespace, name)
-
-    const remote = await this.#remotes[key]
-
-    remote.update(resources)
-  }
-
-  /**
-   * @param {string} namespace
-   * @param {string} name
-   * @returns {Promise<toa.extensions.exposition.Remote>}
-   */
-  async #connect (namespace, name) {
-    const remote = await this.#remote(namespace, name)
-
-    await remote.connect()
-
-    this.depends(remote)
-
-    return remote
-  }
-}
-
-exports.Exposition = Exposition

package/src/factory.js

@@ -1,76 +0,0 @@
-'use strict'
-
-const { Locator } = require('@toa.io/core')
-const { remap } = require('@toa.io/generic')
-
-const { Tenant } = require('./tenant')
-const { Exposition } = require('./exposition')
-const { Server } = require('./server')
-const { Remote } = require('./remote')
-const { Tree } = require('./tree')
-const { Query, constraints } = require('./query')
-
-/**
- * @implements {toa.core.extensions.Factory}
- */
-class Factory {
-  #boot
-
-  /** @type {toa.extensions.exposition.Server} */
-  #server
-
-  constructor (boot) {
-    this.#boot = boot
-    this.#server = new Server()
-  }
-
-  tenant (locator, declaration) {
-    const broadcast = this.#boot.bindings.broadcast(BINDING, NAME, locator.id)
-
-    return new Tenant(broadcast, locator, declaration)
-  }
-
-  service (name) {
-    if (name === undefined || name === 'default' || name === 'resources') return this.#expose()
-  }
-
-  #expose () {
-    const broadcast = this.#boot.bindings.broadcast(BINDING, NAME)
-    const connect = this.#connect.bind(this)
-    const exposition = new Exposition(broadcast, connect)
-
-    exposition.depends(this.#server)
-
-    return exposition
-  }
-
-  /**
-   * @param {string} namespace
-   * @param {string} name
-   * @returns {Promise<toa.extensions.exposition.Remote>}
-   */
-  async #connect (namespace, name) {
-    const locator = new Locator(name, namespace)
-    const remote = await this.#boot.remote(locator)
-    const query = this.#query.bind(this)
-    const tree = new Tree(query)
-
-    return new Remote(this.#server, remote, tree)
-  }
-
-  /**
-   * @param {toa.extensions.exposition.declarations.Node | any} node
-   * @returns {toa.extensions.exposition.Query}
-   */
-  #query (node) {
-    const query = Query.merge(node)
-    const properties = remap(query, (value, key) => new constraints[key](value))
-
-    return new Query(properties)
-  }
-}
-
-const BINDING = '@toa.io/bindings.amqp'
-const NAME = 'exposition'
-
-exports.Factory = Factory

package/src/index.js

@@ -1,9 +0,0 @@
-'use strict'
-
-const { Factory } = require('./factory')
-const { deployment } = require('./deployment')
-const { manifest } = require('./manifest')
-
-exports.Factory = Factory
-exports.deployment = deployment
-exports.manifest = manifest

package/src/manifest.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const { normalize, validate } = require('./.manifest')
-
-const manifest = (node, manifest) => {
-  normalize(node, manifest)
-  validate(node)
-
-  return node
-}
-
-exports.manifest = manifest

package/src/query/criteria.js

@@ -1,55 +0,0 @@
-'use strict'
-
-const { exceptions: { RequestConflictException } } = require('@toa.io/core')
-
-class Criteria {
-  #value
-  #open
-  #logic
-  #right
-
-  constructor (value) {
-    if (value === null) return
-
-    const last = value.slice(-1)
-
-    if (last === ',' || last === ';') {
-      this.#open = true
-      this.#right = true
-      this.#logic = last
-
-      value = value.substring(0, value.length - 1)
-    } else {
-      const first = value.substring(0, 1)
-
-      this.#open = first === ',' || first === ';'
-
-      if (this.#open === true) {
-        this.#right = false
-        this.#logic = first
-
-        value = value.substring(1)
-      }
-    }
-
-    this.#value = value
-  }
-
-  /** @hot */
-  parse (value, operation) {
-    if (operation.query === false) return value
-
-    if (value !== undefined) {
-      if (this.#open === true) {
-        if (this.#right) value = this.#value + this.#logic + value
-        else value = value + this.#logic + this.#value
-      } else {
-        throw new RequestConflictException('Query criteria is defined as closed')
-      }
-    } else value = this.#value
-
-    return value
-  }
-}
-
-exports.Criteria = Criteria

package/src/query/enum.js

@@ -1,35 +0,0 @@
-'use strict'
-
-const { exceptions: { RequestConflictException } } = require('@toa.io/core')
-
-class Enum {
-  #value
-  #keys
-
-  constructor (value) {
-    this.#value = value
-
-    this.#keys = value.reduce((acc, key) => {
-      acc[key] = true
-      return acc
-    }, {})
-  }
-
-  /** @hot */
-  parse (value, operation) {
-    if (operation.type !== 'observation') return value
-
-    if (value === undefined) return this.#value
-    else if (value instanceof Array) {
-      const key = value.find((key) => !(key in this.#keys))
-
-      if (key !== undefined) {
-        throw new RequestConflictException(`Query projection must not contain '${key}'`)
-      }
-    }
-
-    return value
-  }
-}
-
-exports.Enum = Enum

package/src/query/index.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { Query } = require('./query')
-const { Range } = require('./range')
-const { Criteria } = require('./criteria')
-const { Enum } = require('./enum')
-const { Sort } = require('./sort')
-
-exports.Query = Query
-
-exports.constraints = {
-  criteria: Criteria,
-  sort: Sort,
-  omit: Range,
-  limit: Range,
-  projection: Enum
-}

package/src/query/query.js

@@ -1,60 +0,0 @@
-'use strict'
-
-const { merge } = require('@toa.io/generic')
-
-/**
- * @implements {toa.extensions.exposition.Query}
- */
-class Query {
-  #constraints
-
-  constructor (constraints) {
-    this.#constraints = Object.entries(constraints)
-  }
-
-  /** @hot */
-  parse (query, operation) {
-    for (const [key, constraint] of this.#constraints) {
-      const value = constraint.parse(query?.[key], operation)
-
-      if (value !== undefined) {
-        if (query === undefined) query = {}
-
-        query[key] = value
-      }
-    }
-
-    return query
-  }
-
-  /**
-   * @param {toa.extensions.exposition.declarations.Node} node
-   * @returns {toa.extensions.exposition.declarations.Query}
-   */
-  static merge (node) {
-    const query = {}
-    let current = node
-
-    do {
-      if (current.query !== undefined) merge(query, current.query, { ignore: true })
-
-      current = current.parent
-    } while (current !== undefined)
-
-    merge(query, DEFAULTS, { ignore: true })
-
-    return query
-  }
-}
-
-const DEFAULTS = {
-  omit: {
-    range: [0, 1000]
-  },
-  limit: {
-    value: 100,
-    range: [1, 100]
-  }
-}
-
-exports.Query = Query