@toa.io/core 1.0.0-alpha.292 → 1.0.0-alpha.299

package/source/entities/entity.ts

@@ -1,137 +0,0 @@
-import { EntityContractException, EntityGuardException } from '../exceptions.js'
-import { newid } from './newid.js'
-import type { Schema } from '@toa.io/schemas'
-import type { Guard } from '../guard.js'
-import type { Record } from '../types/storages.js'
-import type { Event } from '../types/state.js'
-
-export class Entity {
-  public deleted = false
-
-  readonly #schema: Schema
-  readonly #blank: object
-  readonly #guards: Guard[] | undefined
-  #origin: Record | null = null
-  #state!: Record
-  #mutable = true
-
-  /**
-   * A record makes an entity of what a storage holds; a string, or nothing at all, makes a
-   * blank one under that identity, out of what the component declared a record starts as.
-   *
-   * @param blank what the component declares a record holds before anything is written to it
-   * @param mutable whether the entity may be modified and committed
-   */
-  // eslint-disable-next-line max-params
-  public constructor(
-    schema: Schema,
-    blank: object,
-    argument?: Record | string,
-    guards?: Guard[],
-    mutable = true
-  ) {
-    this.#schema = schema
-    this.#blank = blank
-    this.#guards = guards
-
-    if (typeof argument === 'object') this.#acquire(argument, mutable)
-    else this.#write(this.#compose(argument ?? newid()))
-  }
-
-  public get(): Record {
-    return this.#state
-  }
-
-  public set(value: Record): void {
-    if (!this.#mutable)
-      throw new Error('Entity acquired by a read-only operation cannot be modified')
-
-    this.#guard(value)
-
-    const error = this.#schema.fit(value)
-
-    if (error !== null) throw new EntityContractException(error, value)
-
-    this.#revive(value)
-    this.#write(value)
-  }
-
-  public event(input?: object): Event {
-    return {
-      origin: this.#origin,
-      state: this.#state,
-      trailers: this.#state._trailers,
-      input
-    }
-  }
-
-  /**
-   * 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.
-   */
-  #acquire(record: Record, mutable: boolean): void {
-    this.#mutable = mutable
-
-    if (!mutable) {
-      this.#write(record)
-
-      return
-    }
-
-    this.#write(structuredClone(record))
-    this.#origin = record
-  }
-
-  /**
-   * A blank is not validated: what the component declared is fitted once, at boot, and the
-   * system properties are the runtime's own. It is copied because every entity the component
-   * makes is written over its own.
-   */
-  #compose(id: string): Record {
-    return { id, VERSION: 0, DELETED: null, ...structuredClone(this.#blank) } as Record
-  }
-
-  #guard(value: Record): void {
-    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: Record): void {
-    if (this.#origin?.DELETED == null || value.DELETED !== this.#origin.DELETED) return
-
-    value.DELETED = null
-    this.deleted = false
-  }
-
-  #write(value: Record): void {
-    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/source/entities/factory.ts

@@ -1,52 +0,0 @@
-import { newid } from './newid.js'
-import { Entity } from './entity.js'
-import { EntitySet } from './set.js'
-import { Changeset } from './changeset.js'
-import type { Schema } from '@toa.io/schemas'
-import type { Guard } from '../guard.js'
-import type { Query, Record } from '../types/storages.js'
-
-/** The two schemas a component's records are held to, and what a new one starts as. */
-export interface Schemas {
-  /** what a stored record must fit */
-  entity: Schema
-
-  /** what a changeset must fit: the same properties, none of them required */
-  changeset: Schema
-}
-
-export class Factory {
-  readonly #schemas: Schemas
-  readonly #blank: object
-  readonly #guards: Guard[] | undefined
-
-  public constructor(schemas: Schemas, blank: object, guards?: Guard[]) {
-    this.#schemas = schemas
-    this.#blank = blank
-    this.#guards = guards
-  }
-
-  public fit(values: object): void {
-    this.#schemas.entity.validate({ id: newid(), ...this.#blank, ...values }, 'Entity')
-  }
-
-  public init(id?: string): Entity {
-    return new Entity(this.#schemas.entity, this.#blank, id, this.#guards)
-  }
-
-  public object(record: Record, mutable = true): Entity {
-    return new Entity(this.#schemas.entity, this.#blank, record, this.#guards, mutable)
-  }
-
-  public objects(recordset: Record[], init?: string[], mutable = true): EntitySet {
-    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)
-  }
-
-  public changeset(query: Query): Changeset {
-    return new Changeset(this.#schemas.changeset, query)
-  }
-}

package/source/entities/index.ts

@@ -1,4 +0,0 @@
-export { Factory } from './factory.js'
-export { Entity } from './entity.js'
-export { EntitySet } from './set.js'
-export { Changeset } from './changeset.js'

package/source/entities/newid.ts

@@ -1,9 +0,0 @@
-import * as uuid from 'uuid'
-
-export function newid(): string {
-  const buf = Buffer.alloc(16)
-
-  uuid.v7(undefined, buf)
-
-  return buf.toString('hex')
-}

package/source/entities/set.ts

@@ -1,27 +0,0 @@
-import { SystemException } from '../exceptions.js'
-import type { Entity } from './entity.js'
-import type { Record } from '../types/storages.js'
-import type { Event } from '../types/state.js'
-
-export class EntitySet {
-  readonly #set: Entity[]
-
-  public constructor(set: Entity[]) {
-    this.#set = set
-  }
-
-  public get(): Record[] {
-    return this.#set.map((entity) => entity.get())
-  }
-
-  public set(values: Record[]): void {
-    if (values.length !== this.#set.length)
-      throw new SystemException('Objects array must not be modified')
-
-    values.forEach((value, index) => this.#set[index].set(value))
-  }
-
-  public events(input?: object): Event[] {
-    return this.#set.map((entity) => entity.event(input))
-  }
-}

package/source/event.ts

@@ -1,57 +0,0 @@
-import { console, current, encode, type SpanOptions } from 'openspan'
-import { Connector } from './connector.js'
-import type { Emitter } from './types/bindings.js'
-import type { Event as Bridge } from './types/bridges.js'
-import type { Message } from './types/message.js'
-import type { Event as StateEvent } from './types/state.js'
-
-export interface Definition {
-  conditioned?: boolean
-  subjective?: boolean
-  label?: string
-}
-
-export class Event extends Connector {
-  readonly #emitter: Emitter
-  readonly #bridge: Bridge | undefined
-  readonly #conditioned: boolean | undefined
-  readonly #subjective: boolean | undefined
-  readonly #label: string
-
-  public constructor(definition: Definition, emitter: Emitter, bridge?: Bridge) {
-    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)
-  }
-
-  public async emit(event: StateEvent): Promise<void> {
-    if (this.#conditioned === false || (await this.#bridge?.condition(event)) === true) {
-      const payload =
-        this.#subjective === true ? await this.#bridge?.payload(event) : event.state
-
-      const message: Message = { payload }
-
-      const options: SpanOptions = {
-        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/source/exceptions.ts

@@ -1,133 +0,0 @@
-import { swap } from '@toa.io/generic'
-import type { SchemaError } from '@toa.io/schemas'
-
-export const codes = {
-  System: 0,
-
-  Contract: 200,
-  RequestSyntax: 201,
-  RequestContract: 202,
-  RequestConflict: 203,
-  ResponseContract: 211,
-  EntityContract: 212,
-  EntityGuard: 213,
-  QuerySyntax: 221,
-
-  State: 300,
-  StateNotFound: 302,
-  StatePrecondition: 303,
-  StateConcurrency: 304,
-  StateInitialization: 305,
-  Duplicate: 306,
-
-  Communication: 400,
-  Transmission: 401
-}
-
-export class Exception {
-  public readonly code: number
-  public readonly message: string
-  public cause?: unknown;
-
-  /** what a contract exception copies off the schema error it refused with */
-  [key: string]: unknown
-
-  public constructor(code: number, message: string, cause?: unknown) {
-    this.code = code
-    this.message = message
-
-    if (cause !== undefined) this.cause = cause
-  }
-}
-
-export class SystemException extends Exception {
-  public readonly stack?: string
-
-  public constructor(error: Error | string) {
-    super(codes.System, typeof error === 'string' ? error : error.message)
-
-    if (typeof error !== 'string' && error.stack !== undefined) this.stack = error.stack
-  }
-}
-
-export class ContractException extends Exception {
-  public constructor(
-    code: number | undefined,
-    error: SchemaError | string | null,
-    cause?: unknown
-  ) {
-    super(
-      code ?? codes.Contract,
-      typeof error === 'string' ? error : (error?.message ?? ''),
-      cause
-    )
-
-    if (typeof error === 'object' && error !== null)
-      for (const k of ['keyword', 'property', 'schema', 'path', 'params'] as const)
-        if (k in error) this[k] = (error as unknown as Record<string, unknown>)[k]
-  }
-}
-
-export class RequestContractException extends ContractException {
-  public constructor(error: SchemaError | string, cause?: unknown) {
-    super(codes.RequestContract, error, cause)
-  }
-}
-
-export class ResponseContractException extends ContractException {
-  public constructor(error: SchemaError | string, cause?: unknown) {
-    super(codes.ResponseContract, error, cause)
-  }
-}
-
-export class EntityContractException extends ContractException {
-  public constructor(error: SchemaError | string, cause?: unknown) {
-    super(codes.EntityContract, error, cause)
-  }
-}
-
-export class EntityGuardException extends ContractException {
-  public constructor(name: string, cause?: unknown) {
-    super(codes.EntityGuard, name, cause)
-  }
-}
-
-// #region exports
-
-// a module's exports are static, so the ones that follow a code are named rather
-// than generated onto the namespace
-type Derived = new (message?: string, cause?: unknown) => Exception
-
-function derive(name: keyof typeof codes): Derived {
-  const classname = name + 'Exception'
-
-  const derived = class extends Exception {
-    public constructor(message?: string, cause?: unknown) {
-      super(
-        codes[name],
-        message === undefined ? classname : `${classname}: ${message}`,
-        cause
-      )
-    }
-  }
-
-  // the name is the class's own, and a class expression has none worth reporting
-  Object.defineProperty(derived, 'name', { value: classname })
-
-  return derived
-}
-
-export const RequestSyntaxException = derive('RequestSyntax')
-export const RequestConflictException = derive('RequestConflict')
-export const QuerySyntaxException = derive('QuerySyntax')
-export const StateException = derive('State')
-export const StateNotFoundException = derive('StateNotFound')
-export const StatePreconditionException = derive('StatePrecondition')
-export const StateConcurrencyException = derive('StateConcurrency')
-export const StateInitializationException = derive('StateInitialization')
-export const DuplicateException = derive('Duplicate')
-export const CommunicationException = derive('Communication')
-export const TransmissionException = derive('Transmission')
-
-export const names = swap(codes)
-// #endregion

package/source/exposition.ts

@@ -1,33 +0,0 @@
-import { Connector } from './connector.js'
-import type { Locator } from './locator.js'
-
-interface Manifest {
-  namespace: string
-  name: string
-  entity?: object
-  operations?: object
-  events?: object
-}
-
-export class Exposition extends Connector {
-  public readonly locator: Locator
-
-  readonly #exposition: Partial<Manifest>
-
-  public constructor(locator: Locator, manifest: Manifest) {
-    super()
-
-    this.locator = locator
-    this.#exposition = expose(manifest)
-  }
-
-  public async invoke(): Promise<{ output: Partial<Manifest> }> {
-    return { output: this.#exposition }
-  }
-}
-
-function expose(manifest: Manifest): Partial<Manifest> {
-  const { namespace, name, entity, operations, events } = manifest
-
-  return { namespace, name, entity, operations, events }
-}

package/source/guard.ts

@@ -1,16 +0,0 @@
-import type { Guard as Bridge } from './types/bridges.js'
-
-export class Guard {
-  public readonly name: string
-
-  readonly #bridge: Bridge
-
-  public constructor(name: string, bridge: Bridge) {
-    this.name = name
-    this.#bridge = bridge
-  }
-
-  public fit(state: object, origin: object | null): boolean {
-    return this.#bridge.fit(state, origin)
-  }
-}

package/source/index.ts

@@ -1,36 +0,0 @@
-export { Assignment } from './assignment.js'
-export { Call } from './call.js'
-export { Cascade } from './cascade.js'
-export { Component } from './component.js'
-export { Composition } from './composition.js'
-export { Connector } from './connector.js'
-export { Context } from './context.js'
-export { Discovery } from './discovery.js'
-export { Effect } from './effect.js'
-export { Emission } from './emission.js'
-export { Event } from './event.js'
-export { Exposition } from './exposition.js'
-export { Locator } from './locator.js'
-export { Observation } from './observation.js'
-export { Outbox } from './outbox/index.js'
-export { Operation } from './operation.js'
-export { Query } from './query.js'
-export { Receiver } from './receiver.js'
-export { Reflection } from './reflection.js'
-export { Remote } from './remote.js'
-export { State } from './state.js'
-export { Transition } from './transition.js'
-export { Transmission } from './transmission.js'
-export { Unmanaged } from './unmanaged.js'
-export { Guard } from './guard.js'
-export * as entities from './entities/index.js'
-export * as exceptions from './exceptions.js'
-export * as contract from './contract/index.js'
-
-export type { Exception } from './exceptions.js'
-export type { Invocable } from './component.js'
-export type { Explicable } from './remote.js'
-export type { Scoped, Store } from './operation.js'
-export type { Source as ReflectionSource } from './reflection.js'
-export type { Explanation } from './contract/request.js'
-export type { JSONSchema } from './contract/schemas.js'

package/source/locator.ts

@@ -1,37 +0,0 @@
-import { concat } from '@toa.io/generic'
-
-/** Where a component is, as every name derived from it. */
-export class Locator {
-  public readonly name: string
-  public readonly namespace: string | undefined
-
-  public readonly id: string
-  public readonly label: string
-  public readonly uppercase: string
-  public readonly lowercase: string
-
-  public constructor(name: string, namespace?: string) {
-    if (name === undefined) throw new TypeError('Locator name must be defined')
-
-    this.name = name
-    this.namespace = namespace
-
-    this.id = concat(namespace, '.') + name
-    this.label = (concat(namespace, '-') + name).toLowerCase()
-    this.uppercase = (concat(namespace, '_') + name).toUpperCase()
-    this.lowercase = (concat(namespace, '_') + name).toLowerCase()
-  }
-
-  public static parse(string: string): Locator {
-    const [namespace, name] = string.split(DOT)
-
-    if (name === undefined) return new Locator(namespace)
-    else return new Locator(name, namespace)
-  }
-
-  public hostname(prefix?: string): string {
-    return concat(prefix?.toLowerCase(), '-') + this.label
-  }
-}
-
-const DOT = '.'

package/source/observation.ts

@@ -1,16 +0,0 @@
-import { Operation } from './operation.js'
-import type { Store } from './operation.js'
-import type { Entity } from './entities/entity.js'
-
-export class Observation extends Operation {
-  protected override async run(store: Store): Promise<void> {
-    const scope = store.scope as Entity | null
-
-    if (
-      scope === null ||
-      (scope?.deleted === true && (store.request.query as any)?.options?.deleted !== true)
-    )
-      store.reply = null
-    else await super.run(store)
-  }
-}