@toa.io/core 0.24.0-alpha.9 → 1.0.0-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/core",
-  "version": "0.24.0-alpha.9",
+  "version": "1.0.0-alpha.10",
   "description": "Toa Core",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -12,7 +12,7 @@
     "url": "https://github.com/toa-io/toa/issues"
   },
   "main": "src/index.js",
-  "types": "types/index.d.ts",
+  "types": "types/index.ts",
   "publishConfig": {
     "access": "public"
   },
@@ -21,11 +21,13 @@
   },
   "dependencies": {
     "@rsql/parser": "1.2.4",
-    "@toa.io/console": "0.24.0-alpha.9",
-    "@toa.io/generic": "0.24.0-alpha.9",
-    "@toa.io/yaml": "0.24.0-alpha.9",
-    "clone-deep": "4.0.1",
+    "@toa.io/console": "1.0.0-alpha.10",
+    "@toa.io/generic": "1.0.0-alpha.10",
+    "@toa.io/yaml": "1.0.0-alpha.10",
     "error-value": "0.3.0"
   },
-  "gitHead": "aaa343035500526a21666a4416ab76a445ab184d"
+  "devDependencies": {
+    "clone-deep": "4.0.1"
+  },
+  "gitHead": "472d582389fbfbfe6804cf01683276ce2cc45bf2"
 }

package/src/assignment.js

@@ -9,13 +9,22 @@ class Assignment extends Operation {
   }
 
   async commit (store) {
-    const { scope, state, reply } = store
+    const {
+      scope,
+      state,
+      reply
+    } = store
 
     if (reply.error !== undefined) return
 
     scope.set(state)
 
-    await this.scope.apply(scope)
+    const output = await this.scope.apply(scope)
+
+    // assignment returns new state by default
+    if (store.reply.output === undefined) {
+      store.reply.output = output
+    }
   }
 }
 

package/src/contract/request.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const clone = require('clone-deep')
-
 const schemas = require('./schemas')
 const { RequestContractException } = require('../exceptions')
 const { Conditions } = require('./conditions')
@@ -12,8 +10,13 @@ class Request extends Conditions {
   /**
    * @returns {toa.schema.JSON}
    */
-  static schema (definition) {
-    const schema = { type: 'object', properties: { authentic: { type: 'boolean' } }, additionalProperties: true }
+  static schema (definition, entity) {
+    const schema = {
+      type: 'object',
+      properties: { authentic: { type: 'boolean' } },
+      additionalProperties: true
+    }
+
     const required = []
 
     if (definition.input !== undefined) {
@@ -23,14 +26,19 @@ class Request extends Conditions {
       schema.properties.input = { type: 'null' }
     }
 
-    if (definition.query === true) required.push('query')
+    if (entity === undefined)
+      definition.query = false
 
-    if (definition.query === false) {
-      schema.not = { required: ['query'] }
-    }
+    if (definition.query === true)
+      required.push('query')
+
+    if (definition.query === false)
+      schema.properties.query = { type: 'null' }
 
     if (definition.query !== false) {
-      const query = clone(schemas.query)
+      const query = structuredClone(schemas.query)
+
+      query.properties.id = entity.schema.properties.id
 
       if (definition.type === 'observation') {
         delete query.properties.version
@@ -49,7 +57,8 @@ class Request extends Conditions {
       schema.properties.query = query
     }
 
-    if (required.length > 0) schema.required = required
+    if (required.length > 0)
+      schema.required = required
 
     return schema
   }

package/src/contract/schemas/index.js

@@ -2,7 +2,6 @@
 
 const { resolve } = require('path')
 const { load } = require('@toa.io/yaml')
-const { freeze } = require('@toa.io/generic')
 
-exports.query = freeze(load.sync(resolve(__dirname, './query.yaml')))
-exports.error = freeze(load.sync(resolve(__dirname, './error.yaml')))
+exports.query = load.sync(resolve(__dirname, './query.yaml'))
+exports.error = load.sync(resolve(__dirname, './error.yaml'))

package/src/contract/schemas/query.yaml

@@ -1,7 +1,6 @@
 type: object
 properties:
-  id:
-    $ref: https://schemas.toa.io/0.0.0/definitions#/definitions/id
+  id: { }
   version:
     type: integer
     minimum: 0

package/src/entities/entity.js

@@ -1,7 +1,9 @@
 'use strict'
 
-const clone = require('clone-deep')
-const { difference, newid } = require('@toa.io/generic')
+const {
+  difference,
+  newid
+} = require('@toa.io/generic')
 
 const { EntityContractException } = require('../exceptions')
 
@@ -14,11 +16,11 @@ class Entity {
     this.#schema = schema
 
     if (typeof argument === 'object') {
-      const object = clone(argument)
+      const object = structuredClone(argument)
       this.set(object)
       this.#origin = argument
     } else {
-      const id = typeof argument === 'string' ? argument : newid()
+      const id = argument === undefined ? newid() : argument
       this.#init(id)
     }
   }
@@ -44,13 +46,23 @@ class Entity {
   }
 
   #init (id) {
-    const value = { ...this.#schema.defaults({ id }), _version: 0 }
+    const value = {
+      ...this.#schema.defaults({ id }),
+      _version: 0
+    }
 
     this.#set(value)
   }
 
   #set (value) {
-    Object.defineProperty(value, 'id', { writable: false, configurable: false })
+    Object.defineProperty(value, 'id', {
+      writable: false,
+      configurable: false
+    })
+
+    if (this.#state !== undefined) {
+      value._version++
+    }
 
     this.#state = value
   }

package/src/exceptions.js

@@ -19,6 +19,7 @@ const codes = {
   StatePrecondition: 303,
   StateConcurrency: 304,
   StateInitialization: 305,
+  Duplicate: 306,
 
   Communication: 400,
   Transmission: 401

package/src/exposition.js

@@ -20,8 +20,8 @@ class Exposition extends Connector {
 }
 
 const expose = (manifest) => {
-  const { namespace, name, operations, events } = manifest
-  return { namespace, name, operations, events }
+  const { namespace, name, operations, events, entity } = manifest
+  return { namespace, name, operations, events, entity }
 }
 
 exports.Exposition = Exposition

package/src/observation.js

@@ -1,7 +1,5 @@
 'use strict'
 
-const { freeze } = require('@toa.io/generic')
-
 const { Operation } = require('./operation')
 
 class Observation extends Operation {
@@ -9,8 +7,6 @@ class Observation extends Operation {
     const scope = await this.query(store.request.query)
     const state = scope === null ? null : scope.get()
 
-    freeze(state)
-
     store.scope = scope
     store.state = state
   }

package/src/query/criteria.js

@@ -33,9 +33,9 @@ const coerce = (node, properties) => {
 }
 
 const COERCE = {
-  number: Number,
-  integer: parseInt,
-  boolean: Boolean
+  number: Number.parseFloat,
+  integer: Number.parseInt,
+  boolean: (value) => value === 'true'
 }
 
 exports.criteria = criteria

package/src/query/options.js

@@ -32,6 +32,9 @@ const projection = (projection, properties) => {
       throw new QuerySyntaxException(`Projection property '${property}' is not defined`)
     }
   }
+
+  if (projection.includes('_version') === false)
+    projection.push('_version')
 }
 
 exports.options = options

package/src/state.js

@@ -4,34 +4,23 @@ const { empty } = require('@toa.io/generic')
 
 const {
   StatePreconditionException,
-  StateNotFoundException,
-  StateInitializationException
+  StateNotFoundException
 } = require('./exceptions')
 
-/**
- * @implements {toa.core.State}
- */
 class State {
-  /** @type {toa.core.Storage} */
+  #dependent
   #storage
-
-  /** @type {toa.core.entity.Factory} */
   #entity
   #emission
-  #initialized
 
-  constructor (storage, entity, emission, initialized) {
+  constructor (storage, entity, emission, dependent) {
     this.#storage = storage
     this.#entity = entity
     this.#emission = emission
-    this.#initialized = initialized
+    this.#dependent = dependent === true
   }
 
   init (id) {
-    // if (this.#initialized === true && id === undefined) {
-    //   throw new StateInitializationException('Cannot initialize entity which is initialized. Use request.query.id to access.')
-    // }
-
     return this.#entity.init(id)
   }
 
@@ -39,12 +28,16 @@ class State {
     const record = await this.#storage.get(query)
 
     if (record === null) {
-      if (this.#initialized && query.id !== undefined && query.version === undefined) return this.init(query.id)
-      else if (query.version !== undefined) throw new StatePreconditionException()
+      if (this.#dependent && query.id !== undefined && query.version === undefined) {
+        return this.init(query.id)
+      } else if (query.version !== undefined) throw new StatePreconditionException()
     }
 
-    if (record === null) return null
-    else return this.#entity.object(record)
+    if (record === null) {
+      return null
+    } else {
+      return this.#entity.object(record)
+    }
   }
 
   async objects (query) {
@@ -79,23 +72,34 @@ class State {
   }
 
   async apply (state) {
-    const { changeset, insert } = state.export()
+    const {
+      changeset,
+      insert
+    } = state.export()
 
     let upsert
 
-    if (this.#initialized && state.query.id !== undefined && state.query.version === undefined) {
+    if (this.#dependent && state.query.id !== undefined && state.query.version === undefined) {
       upsert = insert
     }
 
     const result = await this.#storage.upsert(state.query, changeset, upsert)
 
     if (result === null) {
-      if (state.query.version !== undefined) throw new StatePreconditionException()
-      else throw new StateNotFoundException()
+      if (state.query.version !== undefined) {
+        throw new StatePreconditionException()
+      } else {
+        throw new StateNotFoundException()
+      }
+    } else {
+      // same as above
+      await this.#emission.emit({
+        changeset,
+        state: result
+      })
     }
 
-    // same as above
-    await this.#emission.emit({ changeset, state: result })
+    return result
   }
 }
 

package/src/transition.js

@@ -3,7 +3,12 @@
 const { retry } = require('@toa.io/generic')
 
 const { Operation } = require('./operation')
-const { StateConcurrencyException, StateNotFoundException } = require('./exceptions')
+const {
+  StateConcurrencyException,
+  StateNotFoundException,
+  DuplicateException,
+  Exception
+} = require('./exceptions')
 
 class Transition extends Operation {
   #concurrency
@@ -29,18 +34,29 @@ class Transition extends Operation {
   }
 
   async commit (store) {
-    const { scope, state, reply, retry } = store
+    const {
+      scope,
+      state,
+      reply,
+      retry
+    } = store
 
     if (reply.error !== undefined) return
 
     scope.set(state)
 
-    const ok = await this.scope.commit(scope)
+    const result = await this.scope.commit(scope)
 
-    if (ok !== true) {
-      if (this.#concurrency === 'retry') retry()
-      else throw new StateConcurrencyException()
+    if (result === false ||
+      (result instanceof DuplicateException && result.message.includes('_id'))) {
+      if (this.#concurrency === 'retry') {
+        return retry()
+      } else {
+        throw new StateConcurrencyException()
+      }
     }
+
+    if (result instanceof Exception) throw result
   }
 
   async #retry (store, retry) {

package/test/contract/request.test.js

@@ -17,6 +17,8 @@ beforeEach(() => {
   contract = new Request(fixtures.schema)
 })
 
+const dummy = { schema: { properties: {} } }
+
 it('should extend Conditions', () => {
   expect(contract).toBeInstanceOf(Conditions)
   expect(Conditions).toHaveBeenCalledWith(fixtures.schema)
@@ -38,73 +40,73 @@ describe('schema', () => {
   })
 
   it('should provide schema', () => {
-    expect(Request.schema({})).toBeDefined()
+    expect(Request.schema({}, dummy)).toBeDefined()
   })
 
   it('should add required input if defined', () => {
     const input = { type: 'number' }
 
-    expect(Request.schema({ input }).properties.input).toStrictEqual(input)
+    expect(Request.schema({ input }, dummy).properties.input).toStrictEqual(input)
   })
 
   it('should set input as null if undefined', async () => {
-    expect(Request.schema({}).properties.input).toStrictEqual({ type: 'null' })
+    expect(Request.schema({}, dummy).properties.input).toStrictEqual({ type: 'null' })
   })
 
   it('should contain query if declaration.query is not defined', () => {
-    expect(Request.schema({}).properties.query).toBeDefined()
+    expect(Request.schema({}, dummy).properties.query).toBeDefined()
   })
 
   it('should not contain query if declaration.query is false', () => {
-    delete schema.properties.query
-    schema.not = { required: ['query'] }
-    expect(Request.schema({ query: false })).toStrictEqual(schema)
+    schema.properties.query = { type: 'null' }
+    expect(Request.schema({ query: false }, dummy)).toStrictEqual(schema)
   })
 
   it('should require query if declaration.query is true', () => {
     schema.required = ['query']
-    expect(Request.schema({ query: true }).required).toStrictEqual(expect.arrayContaining(['query']))
+    expect(Request.schema({ query: true }, dummy).required).toStrictEqual(expect.arrayContaining(['query']))
   })
 
   it('should forbid projection for non observations', () => {
-    expect(Request.schema({ type: 'transition' }).properties.query.properties.projection)
+    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.projection)
       .toBe(undefined)
 
-    expect(Request.schema({ type: 'assignment' }).properties.query.properties.projection)
+    expect(Request.schema({ type: 'assignment' }, dummy).properties.query.properties.projection)
       .toBe(undefined)
 
-    expect(Request.schema({ type: 'observation' }).properties.query.properties.projection)
+    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.projection)
       .toBeDefined()
   })
 
   it('should forbid version for observations', () => {
-    expect(Request.schema({ type: 'transition' }).properties.query.properties.version)
+    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.version)
       .toBeDefined()
 
-    expect(Request.schema({ type: 'observation' }).properties.query.properties.version)
+    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.version)
       .toBe(undefined)
   })
 
   it('should allow omit, limit only for set observations', () => {
-    const transition = Request.schema({ type: 'transition' }).properties.query.properties
+    const schema = Request.schema({ type: 'transition' }, dummy)
+    const transition = schema.properties.query.properties
 
     expect(transition.omit).toBeUndefined()
     expect(transition.limit).toBeUndefined()
 
-    const entity = Request.schema({
+    const object = Request.schema({
       type: 'observation',
       scope: 'object'
-    }).properties.query.properties
+    }, dummy).properties.query.properties
 
-    expect(entity.omit).toBeUndefined()
-    expect(entity.limit).toBeUndefined()
+    expect(object.omit).toBeUndefined()
+    expect(object.limit).toBeUndefined()
 
-    const set = Request.schema({
+    const objects = Request.schema({
       type: 'observation',
       scope: 'objects'
-    }).properties.query.properties
+    }, dummy).properties.query.properties
 
-    expect(set.omit).toBeDefined()
-    expect(set.limit).toBeDefined()
+    expect(objects.omit).toBeDefined()
+    expect(objects.limit).toBeDefined()
   })
 })

package/test/entities/entity.fixtures.js

@@ -16,10 +16,13 @@ const state = () => ({
   _created: generate(),
   _updated: generate(),
   _deleted: generate(),
-  _version: generate()
+  _version: 0
 })
 
-const failed = () => ({ ...state(), fail: true })
+const failed = () => ({
+  ...state(),
+  fail: true
+})
 
 exports.schema = schema
 exports.state = state

package/test/entities/entity.test.js

@@ -28,7 +28,10 @@ describe('argument', () => {
   it('should provide initial state if no argument passed', () => {
     const entity = new Entity(fixtures.schema)
     const defaults = fixtures.schema.defaults.mock.results[0].value
-    const expected = { ...defaults, _version: 0 }
+    const expected = {
+      ...defaults,
+      _version: 0
+    }
 
     expect(entity.get()).toStrictEqual(expected)
   })
@@ -37,7 +40,7 @@ describe('argument', () => {
     const state = fixtures.state()
     const entity = new Entity(fixtures.schema, state)
 
-    expect(entity.get()).toStrictEqual(state)
+    expect(entity.get()).toEqual(state)
   })
 })
 
@@ -51,10 +54,13 @@ it('should provide event', () => {
 
   const event = entity.event()
 
-  expect(event).toStrictEqual({
+  expect(event).toEqual({
     state,
     origin,
-    changeset: { foo: 'new value' }
+    changeset: {
+      foo: 'new value',
+      _version: 1
+    }
   })
 })
 

package/types/bindings.d.ts

@@ -1,26 +1,26 @@
 import * as _core from './index'
 
-declare namespace toa.core.bindings {
+declare namespace toa.core.bindings{
 
   type Properties = {
     async?: boolean
   }
 
-  interface Consumer extends _core.Connector {
+  interface Consumer extends _core.Connector{
     request (request: Request): Promise<_core.Reply>
   }
 
-  interface Emitter extends _core.Connector {
+  interface Emitter extends _core.Connector{
     emit (message: _core.Message): Promise<void>
   }
 
-  interface Broadcast<L> extends _core.Connector {
+  interface Broadcast<L> extends _core.Connector{
     transmit<T> (label: L, payload: T): Promise<void>
 
     receive<T> (label: L, callback: (payload: T) => void | Promise<void>): Promise<void>
   }
 
-  interface Factory {
+  interface Factory{
     producer? (locator: _core.Locator, endpoints: Array<string>, producer: _core.Component): _core.Connector
 
     consumer? (locator: _core.Locator, endpoint: string): Consumer
@@ -37,4 +37,4 @@ declare namespace toa.core.bindings {
 export type Emitter = toa.core.bindings.Emitter
 export type Factory = toa.core.bindings.Factory
 export type Properties = toa.core.bindings.Properties
-export type Broadcast<L> = toa.core.bindings.Broadcast<L>
+export type Broadcast<L = any> = toa.core.bindings.Broadcast<L>

package/types/bridges.ts

@@ -0,0 +1,30 @@
+import type { Request, Reply } from './request'
+import type { Context } from './context'
+
+export interface Algorithm {
+  mount: (context?: Context) => Promise<void>
+
+  execute: ((input: any, scope: object | object[]) => Promise<Reply>) |
+  ((input: any) => Promise<Reply>) |
+  (() => Promise<Reply>)
+}
+
+export interface Event {
+  condition: (object: object) => Promise<boolean>
+
+  payload: (object: object) => Promise<object>
+}
+
+export interface Receiver {
+  condition: (object: object) => Promise<boolean>
+
+  request: (object: object) => Promise<Request>
+}
+
+export interface Factory {
+  algorithm?: (path: string, name: string, context: Context) => Algorithm
+
+  event?: (path: string, label: string) => Event
+
+  receiver?: (path: string, label: string) => Receiver
+}

package/types/context.d.ts

@@ -3,25 +3,19 @@ import * as _reply from './reply'
 import * as _extensions from './extensions'
 import * as _connector from './connector'
 
-declare namespace toa.core {
+export interface Context extends _connector.Connector{
+  aspects: _extensions.Aspect[]
 
-  interface Context extends _connector.Connector {
-    aspects: _extensions.Aspect[]
+  /**
+   * Calls local endpoint
+   */
+  apply (endpoint: string, request: _request.Request): Promise<_reply.Reply>
 
-    /**
-     * Calls local endpoint
-     */
-    apply(endpoint: string, request: _request.Request): Promise<_reply.Reply>
-
-    /**
-     * Calls remote endpoint
-     */
-    call(namespace: string, name: string, endpoint: string, request: _request.Request): Promise<_reply.Reply>
-
-    // shortcuts
-    [key: string]: any
-  }
+  /**
+   * Calls remote endpoint
+   */
+  call (namespace: string, name: string, endpoint: string, request: _request.Request): Promise<_reply.Reply>
 
+  // shortcuts
+  [key: string]: any
 }
-
-export type Context = toa.core.Context

package/types/{index.d.ts → index.ts}

@@ -4,11 +4,11 @@ export * as storages from './storages'
 export * as bridges from './bridges'
 export * as operations from './operations'
 
-export { Component } from './component'
+export type { Component } from './component'
 export { Connector } from './connector'
-export { Context } from './context'
-export { Exception } from './exception'
+export type { Context } from './context'
+export type { Exception } from './exception'
 export { Locator } from './locator'
-export { Receiver } from './receiver'
-export { Message } from './message'
-export { Request, Query, Reply } from './request'
+export type { Receiver } from './receiver'
+export type { Message } from './message'
+export type { Request, Query, Reply } from './request'

package/types/bridges.d.ts

@@ -1,41 +0,0 @@
-import * as _core from '@toa.io/core/types'
-import type * as reply from './reply'
-import type * as context from './context'
-import type * as connector from './connector'
-
-declare namespace toa.core.bridges {
-
-  interface Algorithm extends connector.Connector {
-    mount(context?: context.Context): Promise<void>
-
-    execute(input: any, scope: object | object[]): Promise<reply.Reply>
-
-    execute(input: any): Promise<reply.Reply>
-
-    execute(): Promise<reply.Reply>
-  }
-
-  interface Event {
-    condition(object): Promise<boolean>
-
-    payload(object): Promise<object>
-  }
-
-  interface Receiver {
-    condition(object): Promise<boolean>
-
-    request(object): Promise<_core.Request>
-  }
-
-  interface Factory {
-    algorithm(path: string, name: string, context: context.Context): Algorithm
-
-    event(path: string, label: string): Event
-
-    receiver(path: string, label: string): Receiver
-  }
-
-}
-
-export type Algorithm = toa.core.bridges.Algorithm
-export type Factory = toa.core.bridges.Factory