@toa.io/core 1.0.0-alpha.283 → 1.0.0-alpha.286

package/src/contract/schemas/index.js

@@ -1,11 +0,0 @@
-import { resolve } from 'path'
-import { readFileSync } from 'node:fs'
-import { yaml } from '@toa.io/generic'
-
-export const query = read(resolve(import.meta.dirname, './query.yaml'))
-export const error = read(resolve(import.meta.dirname, './error.yaml'))
-export const source = read(resolve(import.meta.dirname, './source.yaml'))
-
-function read (path) {
-  return yaml.load(readFileSync(path, 'utf8'))
-}

package/src/contract/schemas/query.yaml

@@ -1,43 +0,0 @@
-type: object
-properties:
-  id:
-    type: string
-  ids:
-    type: array
-    uniqueItems: true
-    minItems: 1
-    items:
-      type: string
-  version:
-    type: integer
-    minimum: 0
-  criteria:
-    type: string
-  search:
-    type: string
-  sample:
-    type: number
-  omit:
-    type: integer
-    minimum: 0
-  limit:
-    type: integer
-    minimum: 0
-  sort:
-    type: array
-    uniqueItems: true
-    minItems: 1
-    items:
-      type: string
-      pattern: ^\w{1,32}(?::(?:asc|desc))?$
-  projection:
-    type: array
-    uniqueItems: true
-    minItems: 1
-    items:
-      type: string
-      not:
-        const: id
-  deleted:
-    type: boolean
-additionalProperties: false

package/src/contract/schemas/source.yaml

@@ -1,23 +0,0 @@
-# Origin of a call, see toa.core.Source.
-# Deliberately permissive on required properties: the contract throws on a mismatch,
-# and a strict union would turn a partially stamped source into a failed business call.
-# `additionalProperties: false` combined with `removeAdditional` is what matters here —
-# it strips whatever a peer puts in, bounding the cardinality of the resulting map.
-type: object
-properties:
-  namespace:
-    type: string
-    maxLength: 64
-  component:
-    type: string
-    maxLength: 64
-  operation:
-    type: string
-    maxLength: 64
-  event:
-    type: string
-    maxLength: 64
-  service:
-    type: string
-    maxLength: 64
-additionalProperties: false

package/src/effect.js

@@ -1,15 +0,0 @@
-import { Observation } from './observation.js'
-
-export class Effect extends Observation {
-
-  async acquire (store) {
-    const { query, entity, input } = store.request
-
-    if (entity === undefined)
-      return super.acquire(store)
-
-    store.scope = await this.scope.ensure(query, entity, input)
-    store.state = store.scope.get()
-  }
-
-}

package/src/entities/changeset.js

@@ -1,36 +0,0 @@
-import { EntityContractException } from '../exceptions.js'
-
-export class Changeset {
-  /** @type {toa.core.Query} */
-  query
-
-  #schema
-  #state
-
-  constructor (schema, query) {
-    this.query = query
-
-    this.#schema = schema
-    this.#state = {}
-  }
-
-  get () {
-    return this.#state
-  }
-
-  set (value) {
-    const error = this.#schema.match(value)
-
-    if (error !== null)
-      throw new EntityContractException(error, value)
-
-    delete value._version
-    value._updated = Date.now()
-
-    this.#state = value
-  }
-
-  export () {
-    return this.#state
-  }
-}

package/src/entities/entity.js

@@ -1,119 +0,0 @@
-import { EntityContractException, EntityGuardException } from '../exceptions.js'
-import { newid } from './newid.js'
-
-export class Entity {
-  deleted = false
-  #schema
-  #guards
-  #origin = null
-  #state
-  #mutable = true
-
-  /**
-   * @param {boolean} [mutable] whether the entity may be modified and committed
-   */
-  constructor (schema, argument, guards, mutable = true) {
-    this.#schema = schema
-    this.#guards = guards
-
-    if (typeof argument === 'object') {
-      /*
-       * The origin is the pre-image a commit diffs the new state against. An operation
-       * that cannot commit has nothing to diff, so it takes the record as it came from
-       * the storage instead of paying for a deep copy of every record it read.
-       */
-      this.#mutable = mutable
-
-      if (mutable) {
-        this.#set(structuredClone(argument))
-        this.#origin = argument
-      } else
-        this.#set(argument)
-    } else {
-      const id = argument === undefined ? newid() : argument
-      this.#init(id)
-    }
-  }
-
-  get () {
-    return this.#state
-  }
-
-  set (value, optional = false) {
-    if (!this.#mutable)
-      throw new Error('Entity acquired by a read-only operation cannot be modified')
-
-    if (!optional)
-      this.#guard(value)
-
-    const error = optional ? this.#schema.fitOptional(value) : this.#schema.fit(value)
-
-    if (error !== null)
-      throw new EntityContractException(error, value)
-
-    this.#revive(value)
-    this.#set(value)
-  }
-
-  event (input = undefined) {
-    return {
-      origin: this.#origin,
-      state: this.#state,
-      trailers: this.#state._trailers,
-      input
-    }
-  }
-
-  #init (id) {
-    const value = { id, _version: 0 }
-
-    this.set(value, true)
-  }
-
-  #guard (value) {
-    if (this.#guards === undefined)
-      return
-
-    for (const guard of this.#guards) {
-      const ok = guard.fit(value, this.#origin)
-
-      if (ok === false)
-        throw new EntityGuardException(guard.name, value)
-    }
-  }
-
-  // deletion is only expressed as a new _deleted timestamp,
-  // so committing over a tombstone without touching it means revival
-  #revive (value) {
-    if (this.#origin?._deleted == null || value._deleted !== this.#origin._deleted)
-      return
-
-    value._deleted = null
-    this.deleted = false
-  }
-
-  #set (value) {
-    if (!('_trailers' in value))
-      Object.defineProperty(value, '_trailers', {
-        writable: false,
-        configurable: false,
-        enumerable: false,
-        value: {}
-      })
-
-    if (!('_created' in value)) {
-      value._created = Date.now()
-      value._updated ??= value._created
-    }
-
-    if ('_deleted' in value && value._deleted !== null)
-      this.deleted = true
-
-    if (this.#state !== undefined) {
-      value._updated = Date.now()
-      value._version++
-    }
-
-    this.#state = value
-  }
-}

package/src/entities/factory.js

@@ -1,40 +0,0 @@
-import { newid } from './newid.js'
-import { Entity } from './entity.js'
-import { EntitySet } from './set.js'
-import { Changeset } from './changeset.js'
-
-export class Factory {
-  #schema
-  #guards
-
-  constructor (schema, guards) {
-    this.#schema = schema
-    this.#guards = guards
-  }
-
-  fit (values) {
-    this.#schema.validate({ id: newid(), ...values }, 'Entity')
-  }
-
-  init (id) {
-    return new Entity(this.#schema, id, this.#guards)
-  }
-
-  object (record, mutable = true) {
-    return new Entity(this.#schema, record, this.#guards, mutable)
-  }
-
-  objects (recordset, init, mutable = true) {
-    const set = recordset.map((record) => this.object(record, mutable))
-
-    if (init !== undefined) 
-      for (const id of init)
-        set.unshift(this.init(id))
-
-    return new EntitySet(set)
-  }
-
-  changeset (query) {
-    return new Changeset(this.#schema, query)
-  }
-}

package/src/entities/index.js

@@ -1 +0,0 @@
-export { Factory } from './factory.js'

package/src/event.js

@@ -1,54 +0,0 @@
-import { console, current, encode } from 'openspan'
-import { Connector } from './connector.js'
-
-/**
- * @implements {toa.core.Event}
- */
-export class Event extends Connector {
-  /** @type {toa.core.bindings.Emitter} */
-  #emitter
-  #bridge
-  #conditioned
-  #subjective
-
-  /** @type {string} */
-  #label
-
-  constructor (definition, emitter, bridge = undefined) {
-    super()
-
-    this.#conditioned = definition.conditioned
-    this.#subjective = definition.subjective
-    this.#label = definition.label ?? 'event'
-    this.#emitter = emitter
-    this.#bridge = bridge
-
-    this.depends(emitter)
-
-    if (bridge !== undefined) this.depends(bridge)
-  }
-
-  async emit (event) {
-    if (this.#conditioned === false || await this.#bridge.condition(event) === true) {
-      const payload = this.#subjective ? await this.#bridge.payload(event) : event.state
-
-      /** @type {toa.core.Message} */
-      const message = { payload }
-
-      const options = {
-        name: `${this.#label} publish`,
-        kind: 'producer',
-        attributes: { 'messaging.destination.name': this.#label }
-      }
-
-      await console.span(options, async () => {
-        const context = current()
-
-        if (context !== undefined)
-          message.telemetry = encode(context)
-
-        await this.#emitter.emit(message)
-      })
-    }
-  }
-}

package/src/exposition.js

@@ -1,24 +0,0 @@
-import { Connector } from './connector.js'
-
-export class Exposition extends Connector {
-  locator
-
-  #exposition
-
-  constructor (locator, manifest) {
-    super()
-
-    this.locator = locator
-    this.#exposition = expose(manifest)
-  }
-
-  async invoke () {
-    return { output: this.#exposition }
-  }
-}
-
-const expose = (manifest) => {
-  const { namespace, name, entity, operations, events } = manifest
-
-  return { namespace, name, entity, operations, events }
-}

package/src/guard.js

@@ -1,13 +0,0 @@
-export class Guard {
-  name
-  #bridge
-
-  constructor (name, bridge) {
-    this.name = name
-    this.#bridge = bridge
-  }
-
-  fit (state, origin) {
-    return this.#bridge.fit(state, origin)
-  }
-}

package/src/observation.js

@@ -1,8 +0,0 @@
-import { Operation } from './operation.js'
-
-export class Observation extends Operation {
-  async run (store) {
-    if (store.scope === null || (store.scope?.deleted === true && store.request.query?.options?.deleted !== true)) store.reply = null
-    else await super.run(store)
-  }
-}

package/src/operation.js

@@ -1,95 +0,0 @@
-import { Connector } from './connector.js'
-import { SystemException, RequestContractException } from './exceptions.js'
-import { Readable } from 'node:stream'
-
-export class Operation extends Connector {
-  scope
-
-  /**
-   * Whether what this operation acquires may be modified and committed. Only a
-   * transition commits, and only a commit needs the pre-image an entity keeps
-   * to diff the new state against.
-   *
-   * @protected
-   */
-  mutable = false
-
-  #cascade
-  #contracts
-  #query
-  #scope
-
-  constructor (cascade, scope, contracts, query, definition) {
-    super()
-
-    this.scope = scope
-
-    this.#cascade = cascade
-    this.#contracts = contracts
-    this.#query = query
-    this.#scope = definition.scope
-
-    this.depends(cascade)
-  }
-
-  async invoke (request) {
-    try {
-      if (request.authentic !== true)
-        this.#contracts.request.fit(request)
-
-      if ('query' in request)
-        request.query = this.#query.parse(request.query)
-
-      // validate entity
-      if ('entity' in request)
-        this.scope.fit(request.entity)
-
-      const store = { request }
-
-      return await this.process(store)
-    } catch (e) {
-      const exception = e instanceof Error ? new SystemException(e) : e
-
-      return { exception }
-    }
-  }
-
-  async process (store) {
-    await this.acquire(store)
-    await this.run(store)
-    await this.commit(store)
-
-    return store.reply
-  }
-
-  async acquire (store) {
-    if (this.#scope === 'none')
-      return
-
-    const scope = await this.query(store.request.query)
-    const raw = scope === null || scope instanceof Readable
-
-    store.scope = scope
-    store.state = raw ? scope : scope.get()
-  }
-
-  async run (store) {
-    const { request, state } = store
-    const reply = await this.#cascade.run(request.input, state)
-
-    // validate reply only on local environments
-    if (process.env.TOA_ENV === 'local' && !(reply instanceof Readable))
-      this.#contracts.reply.fit(reply)
-
-    store.reply = reply
-  }
-
-  async commit () {}
-
-  async query (query) {
-    if (query === undefined)
-      throw new RequestContractException('Request query is required')
-
-    return this.scope[this.#scope](query, this.mutable)
-  }
-}

package/src/query/criteria.js

@@ -1,37 +0,0 @@
-import { parse } from '@rsql/parser'
-import { QuerySyntaxException } from '../exceptions.js'
-
-export const criteria = (criteria, properties) => {
-  let ast
-
-  try {
-    ast = parse(criteria)
-  } catch (e) {
-    throw new QuerySyntaxException(e.message)
-  }
-
-  if (properties !== undefined) coerce(ast, properties)
-
-  return ast
-}
-
-const coerce = (node, properties) => {
-  if (node.type === 'COMPARISON' && node.left?.type === 'SELECTOR' && node.right?.type === 'VALUE') {
-    const property = properties[node.left.selector]
-
-    if (property === undefined) {
-      throw new QuerySyntaxException(`Criteria selector '${node.left.selector}' is not defined`)
-    }
-
-    if (COERCE[property.type] !== undefined) { node.right.value = COERCE[property.type](node.right.value) }
-  } else {
-    if (node.left !== undefined) coerce(node.left, properties)
-    if (node.right !== undefined) coerce(node.right, properties)
-  }
-}
-
-const COERCE = {
-  number: Number.parseFloat,
-  integer: Number.parseInt,
-  boolean: (value) => value === 'true'
-}

package/src/query/options.js

@@ -1,37 +0,0 @@
-import { QuerySyntaxException } from '../exceptions.js'
-
-export const options = (options, properties, system) => {
-  if (options.sort !== undefined) options.sort = sort(options.sort, properties)
-
-  if (options.projection !== undefined) projection(options.projection, properties)
-
-  return options
-}
-
-const sort = (sort, properties) => {
-  const result = []
-
-  for (const sorting of sort) {
-    const [property, direction] = sorting.split(':')
-
-    if (properties[property] === undefined) {
-      throw new QuerySyntaxException(`Sort property '${property}' is not defined`)
-    }
-
-    result.push([property, direction || 'asc'])
-  }
-
-  return result
-}
-
-const projection = (projection, properties) => {
-  for (const property of projection) {
-    if (properties[property] === undefined) {
-      throw new QuerySyntaxException(`Projection property '${property}' is not defined`)
-    }
-  }
-
-  for (const property of ['_version', '_created', '_updated', '_deleted'])
-    if (!projection.includes(property))
-      projection.push(property)
-}

package/src/receiver.js

@@ -1,123 +0,0 @@
-import { console, decode, run } from 'openspan'
-import { add } from '@toa.io/generic'
-import { Connector } from './connector.js'
-
-/**
- * @implements {toa.core.Receiver}
- */
-export class Receiver extends Connector {
-  /** @type {boolean} */
-  #conditioned
-
-  /** @type {boolean} */
-  #adaptive
-
-  /** @type {string} */
-  #endpoint
-
-  /** @type {string} */
-  #label
-
-  /** @type {string} */
-  #destination
-
-  /** @type {unknown[]} */
-  #arguments
-
-  /** @type {toa.core.Source} */
-  #origin
-
-  #local
-
-  #bridge
-
-  /** @type {object} */
-  #delivery
-
-  /** @type {object} */
-  #processing
-
-  constructor (definition, local, bridge) {
-    super()
-
-    const { conditioned, adaptive, operation } = definition
-
-    this.#conditioned = conditioned
-    this.#adaptive = adaptive
-    this.#endpoint = operation
-    this.#label = definition.label ?? operation
-    this.#destination = definition.destination ?? this.#label
-    this.#arguments = definition.arguments
-    this.#origin = definition.origin
-
-    this.#local = local
-    this.#bridge = bridge
-
-    this.depends(local)
-    if (bridge !== undefined) this.depends(bridge)
-
-    /*
-     * The delivery span is created on behalf of the messaging destination, so that
-     * each consumer forms its own complete producer/consumer pair, and service graphs
-     * display fan-out correctly: producer -> destination -> each consumer
-     * (Tempo pairs spans one-to-one, thus multiple consumers can not pair
-     * with a single producer span, see grafana/tempo#5408)
-     */
-    this.#delivery = {
-      name: `${this.#label} deliver`,
-      kind: 'producer',
-      service: this.#destination,
-      attributes: { 'messaging.destination.name': this.#destination }
-    }
-
-    this.#processing = {
-      name: `${this.#label} process`,
-      kind: 'consumer',
-      service: local.locator.id,
-      attributes: { 'messaging.destination.name': this.#destination }
-    }
-  }
-
-  /** @hot */
-  async receive (message) {
-    const { payload, telemetry, ...extensions } = message
-
-    if (this.#conditioned && await this.#bridge.condition(payload) === false) return
-
-    const request = await this.#request(payload)
-
-    add(request, extensions)
-
-    // set after `add`, so that a message field can not spoof the origin
-    if (this.#origin !== undefined) request.source = this.#origin
-
-    // continue the trace from the producer span
-    const remote = telemetry === undefined ? null : decode(telemetry)
-    const task = () => this.#process(request)
-
-    if (remote === null)
-      await task()
-    else
-      await run(remote, task)
-  }
-
-  async #process (request) {
-    return console.span(this.#delivery, async () => console.span(this.#processing, async () => {
-      try {
-        await this.#local.invoke(this.#endpoint, request)
-      } catch (error) {
-        console.error('Receiver error', {
-          component: this.#local.locator.id,
-          endpoint: this.#endpoint,
-          error
-        })
-
-        throw error
-      }
-    }))
-  }
-
-  async #request (payload) {
-    return this.#adaptive ? await this.#bridge.request(payload, ...(this.#arguments ?? [])) : { input: payload }
-  }
-}