@toa.io/core 0.24.0-alpha.2 → 0.24.0-alpha.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/core",
-  "version": "0.24.0-alpha.2",
+  "version": "0.24.0-alpha.21",
   "description": "Toa Core",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -21,11 +21,13 @@
   },
   "dependencies": {
     "@rsql/parser": "1.2.4",
-    "@toa.io/console": "0.24.0-alpha.2",
-    "@toa.io/generic": "0.24.0-alpha.2",
-    "@toa.io/yaml": "0.24.0-alpha.2",
-    "clone-deep": "4.0.1",
+    "@toa.io/console": "0.24.0-alpha.21",
+    "@toa.io/generic": "0.24.0-alpha.21",
+    "@toa.io/yaml": "0.24.0-alpha.21",
     "error-value": "0.3.0"
   },
-  "gitHead": "36cea9ed2e8add73748dc921b670ec92a227fed4"
+  "devDependencies": {
+    "clone-deep": "4.0.1"
+  },
+  "gitHead": "b30bbcf178be9339914e2e5203c61c0da2c3daf2"
 }

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,6 +26,9 @@ class Request extends Conditions {
       schema.properties.input = { type: 'null' }
     }
 
+    if (entity === undefined)
+      definition.query = false
+
     if (definition.query === true) required.push('query')
 
     if (definition.query === false) {
@@ -30,7 +36,9 @@ class Request extends Conditions {
     }
 
     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

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,6 +1,5 @@
 'use strict'
 
-const clone = require('clone-deep')
 const { difference, newid } = require('@toa.io/generic')
 
 const { EntityContractException } = require('../exceptions')
@@ -14,11 +13,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)
     }
   }

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/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

@@ -18,20 +18,16 @@ class State {
   /** @type {toa.core.entity.Factory} */
   #entity
   #emission
-  #initialized
+  #dependent
 
-  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,7 +35,7 @@ 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)
+      if (this.#dependent && query.id !== undefined && query.version === undefined) return this.init(query.id)
       else if (query.version !== undefined) throw new StatePreconditionException()
     }
 
@@ -83,7 +79,7 @@ class State {
 
     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
     }
 

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,74 @@ 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)
+    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.test.js

@@ -37,7 +37,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,7 +51,7 @@ it('should provide event', () => {
 
   const event = entity.event()
 
-  expect(event).toStrictEqual({
+  expect(event).toEqual({
     state,
     origin,
     changeset: { foo: 'new value' }

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>