@live-change/framework 0.7.18 → 0.7.19

package/index.js

@@ -3,10 +3,10 @@ const App = require('./lib/App.js')
 module.exports = App
 
 module.exports.app = () => {
-  if(!global.liveChangeFrameworkApp) {
-    global.liveChangeFrameworkApp = new App()
+  if(!globalThis.liveChangeFrameworkApp) {
+    globalThis.liveChangeFrameworkApp = new App()
   }
-  return global.liveChangeFrameworkApp
+  return globalThis.liveChangeFrameworkApp
 }
 
 module.exports.utils = require('./lib/utils.js')

package/lib/App.js

@@ -33,6 +33,8 @@ const triggerExecutor = require("./processes/triggerExecutor.js")
 const eventListener = require('./processes/eventListener.js')
 
 const utils = require('./utils.js')
+const SplitEmitQueue = require("./utils/SplitEmitQueue.js");
+const SingleEmitQueue = require("./utils/SingleEmitQueue.js");
 
 const debug = require('debug')('framework')
 
@@ -41,6 +43,9 @@ class App {
   constructor(config = {}) {
     this.config = config
     this.splitEvents = false
+    this.shortEvents = false
+    this.shortCommands = false
+    this.shortTriggers = false
 
     this.requestTimeout = config?.db?.requestTimeout || 10*1000
 
@@ -78,6 +83,9 @@ class App {
     this.uidGenerator = uidGenerator(this.instanceId, this.config.uidBorders)
 
     this.activeTimeouts = new Set()
+
+    this.startedServices = {}
+    this.triggerRoutes = {}
   }
 
   createServiceDefinition( definition ) {
@@ -142,6 +150,9 @@ class App {
       oldServiceJson = this.createServiceDefinition({name: service.name}).toJSON()
     }
     let changes = this.computeChanges(oldServiceJson, service)
+    //console.log("OLD SERVICE", JSON.stringify(oldServiceJson, null, '  '))
+    //console.log("NEW SERVICE", JSON.stringify(service.toJSON(), null, '  '))
+    //console.log("CHANGES", JSON.stringify(changes, null, '  '))
 
     /// TODO: chceck for overwriting renames, solve by addeding temporary names
 
@@ -164,6 +175,7 @@ class App {
     await service.start(config)
     console.log("service started", serviceDefinition.name, "!")
     await this.profileLog.end(profileOp)
+    this.startedServices[serviceDefinition.name] = service
     return service
   }
 
@@ -204,6 +216,10 @@ class App {
   }
 
   async trigger(data) {
+    if(this.shortTriggers) {
+      const triggers = this.triggerRoutes[data.route]
+      return await Promise.all(triggers.map(t => t.execute(data)))
+    }
     const profileOp = await this.profileLog.begin({
       operation: "callTrigger", triggerType: data.type, id: data.id, by: data.by
     })
@@ -222,7 +238,14 @@ class App {
   }
 
   async triggerService(service, data, returnArray = false) {
-
+    if(this.shortTriggers) {
+      const service = this.startedServices[service]
+      const triggers = service.triggers[data.type]
+      if(!triggers) return []
+      const result = await Promise.all(triggers.map(t => t.execute(data)))
+      if(!returnArray && Array.isArray(result) && result.length == 1) return result[0]
+      return result
+    }
     if(!data.id) data.id = this.generateUid()
     data.service = service
     data.state = 'new'
@@ -266,45 +289,111 @@ class App {
     if(!data.timestamp) data.timestamp = (new Date()).toISOString()
     data.state = 'new'
 
-    const profileOp = await this.profileLog.begin({
-      operation: "callCommand", commandType: data.type, service: data.service,
-      commandId: data.id, by: data.by, client: data.client
-    })
+    if(this.shortCommands) {
+      const command = data
+      const service = this.startedServices[data.service]
+      const action = service.actions[data.type]
+      const reportFinished = action.definition.waitForEvents ? 'command_' + command.id : undefined
+      const flags = {commandId: command.id, reportFinished}
+      const emit = (!this.splitEvents || this.shortEvents)
+        ? new SingleEmitQueue(service, flags)
+        : new SplitEmitQueue(service, flags)
+      const queuedBy = action.definition.queuedBy
+      if(queuedBy) {
+        const profileOp = await service.profileLog.begin({
+          operation: 'queueCommand', commandType: actionName,
+          commandId: command.id, client: command.client
+        })
+        const keyFunction = typeof queuedBy == 'function' ? queuedBy : (
+          Array.isArray(queuedBy) ? (c) => JSON.stringify(queuedBy.map(k => c[k])) :
+            (c) => JSON.stringify(c[queuedBy]))
+
+        const routine = () => service.profileLog.profile({
+          operation: 'runCommand', commandType: actionName,
+          commandId: command.id, client: command.client
+        }, async () => {
+          const result = await service.app.assertTime('command ' + action.definition.name,
+            action.definition.timeout || 10000,
+            () => action.runCommand(command, (...args) => emit.emit(...args)), command)
+          if(this.shortEvents) {
+            const bucket = {}
+            const eventsPromise = Promise.all(emit.emittedEvents.map(event => {
+              const service = this.startedServices[event.service]
+              const handler = service.events[event.type]
+              service.exentQueue.queue(() => handler.execute(event, bucket))
+            }))
+            if (action.definition.waitForEvents) await eventsPromise
+          } else {
+            const events = await emit.commit()
+            if (action.definition.waitForEvents)
+              await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+          }
+          return result
+        })
+        routine.key = keyFunction(command)
+        const promise = service.keyBasedExecutionQueues.queue(routine)
+        await service.profileLog.endPromise(profileOp, promise)
+        return promise
+      } else {
+        const result = await service.app.assertTime('command ' + action.definition.name,
+          action.definition.timeout || 10000,
+          () => action.runCommand(command, (...args) => emit.emit(...args)), command)
+        if(this.shortEvents) {
+          const bucket = {}
+          console.log("emit", emit)
+          const eventsPromise = Promise.all(emit.emittedEvents.map(event => {
+            const service = this.startedServices[event.service]
+            const handler = service.events[event.type]
+            service.exentQueue.queue(() => handler.execute(event, bucket))
+          }))
+          if (action.definition.waitForEvents) await eventsPromise
+        } else {
+          const events = await emit.commit()
+          if (action.definition.waitForEvents)
+            await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+        }
+        return result
+      }
+    } else { // queue and observe command execution
+      const profileOp = await this.profileLog.begin({
+        operation: "callCommand", commandType: data.type, service: data.service,
+        commandId: data.id, by: data.by, client: data.client
+      })
 
-    const commandsTable = this.splitCommands ? `${data.service}_commands` : 'commands'
-    const objectObservable = this.dao.observable(
+      const commandsTable = this.splitCommands ? `${data.service}_commands` : 'commands'
+      const objectObservable = this.dao.observable(
         ['database', 'tableObject', this.databaseName, commandsTable, data.id],
         ReactiveDao.ObservableValue
-    )
-    await this.dao.request(['database', 'update', this.databaseName, commandsTable, data.id, [
-      { op: 'reverseMerge', value: data }
-    ]])
-    let observer
-    const promise = new Promise((resolve, reject) => {
-      observer = (signal, value) => {
-        if(signal != 'set') return reject('unknownSignal')
-        if(!value) return
-        if(value.state == 'done') return resolve(value.result)
-        if(value.state == 'failed') return reject(value.error)
-      }
-      objectObservable.observe(observer)
-      if(!requestTimeout) {
-        requestTimeout = this.requestTimeout
-      }
-      if(requestTimeout) {
-        const timeout = setTimeout(() => {
-          this.activeTimeouts.delete(timeout)
-          reject('timeout')
-        }, requestTimeout)
-        this.activeTimeouts.add(timeout)
-      }
-    }).finally(() => {
-      objectObservable.unobserve(observer)
-    })
-
-    await this.profileLog.endPromise(profileOp, promise)
+      )
+      await this.dao.request(['database', 'update', this.databaseName, commandsTable, data.id, [
+        {op: 'reverseMerge', value: data}
+      ]])
+      let observer
+      const promise = new Promise((resolve, reject) => {
+        observer = (signal, value) => {
+          if (signal != 'set') return reject('unknownSignal')
+          if (!value) return
+          if (value.state == 'done') return resolve(value.result)
+          if (value.state == 'failed') return reject(value.error)
+        }
+        objectObservable.observe(observer)
+        if (!requestTimeout) {
+          requestTimeout = this.requestTimeout
+        }
+        if (requestTimeout) {
+          const timeout = setTimeout(() => {
+            this.activeTimeouts.delete(timeout)
+            reject('timeout')
+          }, requestTimeout)
+          this.activeTimeouts.add(timeout)
+        }
+      }).finally(() => {
+        objectObservable.unobserve(observer)
+      })
 
-    return promise
+      await this.profileLog.endPromise(profileOp, promise)
+      return promise
+    }
   }
 
   async emitEvents(service, events, flags = {}) {

package/lib/definition/IndexDefinition.js

@@ -28,6 +28,12 @@ class IndexDefinition {
     if(oldIndex.search && this.search && JSON.stringify(oldIndex.search) != JSON.stringify(this.search))
       changes.push({ operation: "indexSearchUpdated", index: this.name })
 
+    const oldStorage = oldIndex.storage || {}
+    const newStorage = this.storage || {}
+    if(JSON.stringify(oldStorage) != JSON.stringify(newStorage)) {
+      changes.push({ operation: "indexStorageChanged", index: this.name, oldStorage, storage: newStorage })
+    }
+
     return changes
   }
 

package/lib/definition/ModelDefinition.js

@@ -58,12 +58,21 @@ class ModelDefinition {
     changes.push(...utils.crudChanges(oldModel.properties || {}, json.properties || {},
         "Property", "property", { model: this.name }))
     changes.push(...utils.crudChanges(oldModel.indexes || {}, json.indexes || {},
-        "Index", "index", { model: this.name }))
+        "Index", "index", { model: this.name, storage: this.storage }))
     if(oldModel.search && !this.search) changes.push({ operation: "searchDisabled", model: this.name })
     if(!oldModel.search && this.search) changes.push({ operation: "searchEnabled", model: this.name })
     if(oldModel.search && this.search && JSON.stringify(oldModel.search) != JSON.stringify(this.search))
       changes.push({ operation: "searchUpdated", model: this.name })
 
+    const oldStorage = oldModel.storage || {}
+    const newStorage = this.storage || {}
+    if(JSON.stringify(oldStorage) != JSON.stringify(newStorage)) {
+      changes.push({ operation: "storageChanged", model: this.name, oldStorage, storage: newStorage })
+      for(let indexName in this.indexes) {
+        changes.push({ operation: "indexStorageChanged", index: indexName, oldStorage, storage: newStorage })
+      }
+    }
+
     return changes
   }
 

package/lib/processes/commandExecutor.js

@@ -7,9 +7,11 @@ async function startCommandExecutor(service, config) {
   if(!config.runCommands) return
 
   service.keyBasedExecutionQueues = service.keyBasedExecutionQueues || new KeyBasedExecutionQueues(r => r.key)
-  
+
+  if(service.app.shortCommands) return
+
   service.commandQueue = new CommandQueue(service.dao, service.databaseName,
-      service.app.splitCommands ? `${service.name}_commands` : 'commands', service.name)
+      service.app.splitCommands ? `${service.name}_commands` : 'commands', service.name, config.runCommands)
   for (let actionName in service.actions) {
     const action = service.actions[actionName]
     if (action.definition.queuedBy) {
@@ -24,9 +26,9 @@ async function startCommandExecutor(service, config) {
         })
         const reportFinished = action.definition.waitForEvents ? 'command_' + command.id : undefined
         const flags = {commandId: command.id, reportFinished}
-        const emit = service.app.splitEvents
-            ? new SplitEmitQueue(service, flags)
-            : new SingleEmitQueue(service, flags)
+        const emit = (!service.app.splitEvents || this.shortEvents)
+          ? new SingleEmitQueue(service, flags)
+          : new SplitEmitQueue(service, flags)
         const routine = () => service.profileLog.profile({
           operation: 'runCommand', commandType: actionName,
           commandId: command.id, client: command.client
@@ -34,9 +36,19 @@ async function startCommandExecutor(service, config) {
           const result = await service.app.assertTime('command ' + action.definition.name,
               action.definition.timeout || 10000,
               () => action.runCommand(command, (...args) => emit.emit(...args)), command)
-          const events = await emit.commit()
-          if (action.definition.waitForEvents)
-            await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+          if(service.app.shortEvents) {
+            const bucket = {}
+            const eventsPromise = Promise.all(emit.emittedEvents.map(event => {
+              const handlerService = service.app.startedServices[event.service]
+              const handler = handlerService.events[event.type]
+              handlerService.exentQueue.queue(() => handler.execute(event, bucket))
+            }))
+            if (action.definition.waitForEvents) await eventsPromise
+          } else {
+            const events = await emit.commit()
+            if (action.definition.waitForEvents)
+              await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+          }
           return result
         })
         routine.key = keyFunction(command)
@@ -52,15 +64,25 @@ async function startCommandExecutor(service, config) {
           }, async () => {
             const reportFinished = action.definition.waitForEvents ? 'command_' + command.id : undefined
             const flags = {commandId: command.id, reportFinished}
-            const emit = service.app.splitEvents
-                ? new SplitEmitQueue(service, flags)
-                : new SingleEmitQueue(service, flags)
+            const emit = (!service.app.splitEvents || this.shortEvents)
+              ? new SingleEmitQueue(service, flags)
+              : new SplitEmitQueue(service, flags)
             const result = await service.app.assertTime('command ' + action.definition.name,
                 action.definition.timeout || 10000,
                 () => action.runCommand(command, (...args) => emit.emit(...args)), command)
-            const events = await emit.commit()
-            if (action.definition.waitForEvents)
-              await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+            if(service.app.shortEvents) {
+              const bucket = {}
+              const eventsPromise = Promise.all(emit.emittedEvents.map(event => {
+                const handlerService = service.app.startedServices[event.service]
+                const handler = handlerService.events[event.type]
+                handlerService.exentQueue.queue(() => handler.execute(event, bucket))
+              }))
+              if (action.definition.waitForEvents) await eventsPromise
+            } else {
+              const events = await emit.commit()
+              if (action.definition.waitForEvents)
+                await service.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
+            }
             return result
           })
       )

package/lib/processes/eventListener.js

@@ -2,18 +2,17 @@ const EventSourcing = require('../utils/EventSourcing.js')
 
 async function startEventListener(service, config) {
   if(!config.handleEvents) return
-    
+
   if(service.app.splitEvents) {
     service.eventSourcing = new EventSourcing(service.dao, service.databaseName,
         'events_'+service.name, service.name,
-        { filter: (event) => event.service == service.name })
+        { filter: (event) => event.service == service.name }, config.handleEvents)
   } else {
     service.eventSourcing = new EventSourcing(service.dao, service.databaseName,
         'events', service.name,
-        { filter: (event) => event.service == service.name })
+        { filter: (event) => event.service == service.name }, config.handleEvents)
   }
 
-
   for (let eventName in service.events) {
     const event = service.events[eventName]
     service.eventSourcing.addEventHandler(eventName, async (ev, bucket) => {
@@ -37,4 +36,4 @@ async function startEventListener(service, config) {
   service.eventSourcing.start()
 }
 
-module.exports = startEventListener
+module.exports = startEventListener

package/lib/processes/triggerExecutor.js

@@ -8,10 +8,20 @@ async function startTriggerExecutor(service, config) {
 
   service.keyBasedExecutionQueues = service.keyBasedExecutionQueues || new KeyBasedExecutionQueues(r => r.key)
 
+  if(service.app.shortTriggers) {
+    for (let triggerName in service.triggers) {
+      service.app.triggerRoutes[triggerName] = service.app.triggerRoutes[triggerName] || []
+      for(let trigger of service.triggers[triggerName]) {
+        service.app.triggerRoutes[triggerName].push({ service, trigger })
+      }
+    }
+    return
+  }
+
   await service.dao.request(['database', 'createTable'], service.databaseName, 'triggerRoutes').catch(e => 'ok')
 
   service.triggerQueue = new CommandQueue(service.dao, service.databaseName,
-      service.app.splitTriggers ? `${service.name}_triggers` : 'triggers', service.name )
+      service.app.splitTriggers ? `${service.name}_triggers` : 'triggers', service.name, config.runCommands)
   for (let triggerName in service.triggers) {
     const triggers = service.triggers[triggerName]
     await service.dao.request(['database', 'put'], service.databaseName, 'triggerRoutes',

package/lib/runtime/Action.js

@@ -35,7 +35,7 @@ class Action {
   }
 
   async callCommand(parameters, clientData) {
-    if(!clientData.roles) throw new Error("no roles")
+    // if(!clientData.roles) throw new Error("no roles") - roles are not required in frontend
     const command = {
       type: this.definition.name,
       service: this.service.name,
@@ -48,4 +48,4 @@ class Action {
   }
 }
 
-module.exports = Action
+module.exports = Action

package/lib/runtime/Dao.js

@@ -8,7 +8,7 @@ function promiseMap(promise, fn) {
 }
 
 function prepareReactiveDaoDefinition(config, clientData) {
-  if(!clientData.roles) throw new Error("no roles")
+  //if(!clientData.roles) throw new Error("no roles")  - roles not required for local dao
   let dao = {}
   let staticDefinitions = []
   if(config.remote) {
@@ -43,7 +43,7 @@ function prepareReactiveDaoDefinition(config, clientData) {
       let methods = {}, values = {}
       for(let actionName in service.actions) {
         let action = service.actions[actionName]
-        if(!clientData.roles) throw new Error("no roles")
+        //if(!clientData.roles) throw new Error("no roles")  - roles not required for local dao
         methods[actionName] = (params) => action.callCommand(params, clientData)
       }
       for(let viewName in service.views) {
@@ -172,13 +172,13 @@ function prepareReactiveDaoDefinition(config, clientData) {
   return dao
 }
 
-class RTCMSDao extends ReactiveDao {
+class Dao extends ReactiveDao {
   constructor(config, clientData) {
-    console.log("CD", clientData)
+    //console.log("CD", clientData)
     super(clientData, prepareReactiveDaoDefinition(config, clientData))
     //console.log("Created dao with clientData",clientData)
-    if( !clientData.roles ) throw new Error("NO ROLES!!")
+    // if( !clientData.roles ) throw new Error("NO ROLES!!") - roles not required for local dao
   }
 }
 
-module.exports = RTCMSDao
+module.exports = Dao

package/lib/runtime/Model.js

@@ -1,4 +1,5 @@
 const ReaderModel = require("./ReaderModel.js")
+const utils = require("../utils.js");
 
 class Model extends ReaderModel {
 
@@ -38,6 +39,64 @@ class Model extends ReaderModel {
     return res
   }
 
+  rangeDelete(range = {}, pathRange = null) {
+    if(typeof range != 'object' || Array.isArray(range)) {
+      const values = Array.isArray(range) ? range : [range]
+      const prefix = values.map(value => value === undefined ? '' : JSON.stringify(value)).join(':')
+      if(pathRange) {
+        return this.rangePath(utils.prefixRange(pathRange, prefix, prefix))
+      }
+      return this.rangePath({ gte: prefix+':', lte: prefix+'_\xFF\xFF\xFF\xFF' })
+    }
+    if(Array.isArray(range)) this.rangePath(range.join(','))
+    this.service.dao.request(['database', 'query'], this.service.databaseName, `(${
+      async (input, output, { tableName, range }) => {
+        await (await input.table(tableName)).range(range).onChange(async (obj, oldObj) => {
+          output.table(tableName).delete(obj.id)
+        })
+      }
+    })`, { tableName: this.tableName, range })
+  }
+
+  indexRangeDelete(index, range = {}, pathRange = null) {
+    if(typeof range != 'object' || Array.isArray(range)) {
+      const values = Array.isArray(range) ? range : [range]
+      const prefix = values.map(value => value === undefined ? '' : JSON.stringify(value)).join(':')
+      if(pathRange) {
+        return this.indexRangeDelete(index, utils.prefixRange(pathRange, prefix, prefix))
+      }
+      return this.indexRangeDelete(index,{ gte: prefix+':', lte: prefix+'_\xFF\xFF\xFF\xFF' })
+    }
+    this.service.dao.request(['database', 'query'], this.service.databaseName, `${
+      async (input, output, { tableName, indexName, range }) => {
+        await (await input.index(indexName)).range(range).onChange(async (ind, oldInd) => {
+          output.table(tableName).delete(ind.to)
+        })
+      }
+    })`, { indexName: this.tableName+'_'+index, tableName: this.tableName, range })
+  }
+
+  indexRangeUpdate(index, update, range = {}, pathRange = null) {
+    if(typeof range != 'object' || Array.isArray(range)) {
+      const values = Array.isArray(range) ? range : [range]
+      const prefix = values.map(value => value === undefined ? '' : JSON.stringify(value)).join(':')
+      if(pathRange) {
+        return this.indexRangeUpdate(index, update, utils.prefixRange(pathRange, prefix, prefix))
+      }
+      return this.indexRangeUpdate(index, update,{ gte: prefix+':', lte: prefix+'_\xFF\xFF\xFF\xFF' })
+    }
+    const operations = Array.isArray(update) ? update : [{ op:'merge', property: null, value: update }]
+    this.service.dao.request(['database', 'query'], this.service.databaseName, `(${
+      async (input, output, { tableName, indexName, range, operations }) => {
+        await (await input.index(indexName)).range(range).onChange(async (ind, oldInd) => {
+          output.table(tableName).update(ind.to, operations)
+        })
+      }
+    })`, { indexName: this.tableName+'_'+index, tableName: this.tableName, range, operations })
+  }
+
+
+
 }
 
 module.exports = Model

package/lib/runtime/ReaderModel.js

@@ -211,41 +211,17 @@ class ReaderModel {
     })`, { indexName: this.tableName+'_'+index, tableName: this.tableName, range }]
   }
 
-  indexRangeDelete(index, range = {}, pathRange = null) {
+  countPath(range = {}, pathRange = null) {
     if(typeof range != 'object' || Array.isArray(range)) {
       const values = Array.isArray(range) ? range : [range]
       const prefix = values.map(value => value === undefined ? '' : JSON.stringify(value)).join(':')
       if(pathRange) {
-        return this.indexRangeDelete(index, utils.prefixRange(pathRange, prefix, prefix))
+        return this.countPath(utils.prefixRange(pathRange, prefix, prefix))
       }
-      return this.indexRangeDelete(index,{ gte: prefix+':', lte: prefix+'_\xFF\xFF\xFF\xFF' })
+      return this.countPath({ gte: prefix+':', lte: prefix+'_\xFF\xFF\xFF\xFF' })
     }
-    this.service.dao.request(['database', 'query'], this.service.databaseName, `${
-        async (input, output, { tableName, indexName, range }) => {
-          await (await input.index(indexName)).range(range).onChange(async (ind, oldInd) => {
-            output.table(tableName).delete(ind.to)
-          })
-        }
-    })`, { indexName: this.tableName+'_'+index, tableName: this.tableName, range })
-  }
-
-  indexRangeUpdate(index, update, range = {}, pathRange = null) {
-    if(typeof range != 'object' || Array.isArray(range)) {
-      const values = Array.isArray(range) ? range : [range]
-      const prefix = values.map(value => value === undefined ? '' : JSON.stringify(value)).join(':')
-      if(pathRange) {
-        return this.indexRangeUpdate(index, update, utils.prefixRange(pathRange, prefix, prefix))
-      }
-      return this.indexRangeUpdate(index, update,{ gte: prefix+':', lte: prefix+'_\xFF\xFF\xFF\xFF' })
-    }
-    const operations = Array.isArray(update) ? update : [{ op:'merge', property: null, value: update }]
-    this.service.dao.request(['database', 'query'], this.service.databaseName, `(${
-        async (input, output, { tableName, indexName, range, operations }) => {
-          await (await input.index(indexName)).range(range).onChange(async (ind, oldInd) => {
-            output.table(tableName).update(ind.to, operations)
-          })
-        }
-    })`, { indexName: this.tableName+'_'+index, tableName: this.tableName, range, operations })
+    if(Array.isArray(range)) this.rangePath(range.join(','))
+    return ['database', 'tableCount', this.service.databaseName, this.tableName, range]
   }
 
   observable(id) {
@@ -278,6 +254,12 @@ class ReaderModel {
   async sortedIndexRangeGet(index, range, pathRange = null) {
     return this.service.dao.get(this.sortedIndexRangePath(index, range, pathRange), ReactiveDao.ObservableList)
   }
+  countObservable(range) {
+    return this.service.dao.observable(this.countPath(range), ReactiveDao.ObservableList)
+  }
+  async countGet(range) {
+    return this.service.dao.get(this.countPath(range), ReactiveDao.ObservableList)
+  }
 
   condition(id, condition = x => !!x, timeout = 10000) {
     return new Promise((resolve, reject) => {

package/lib/runtime/Service.js

@@ -5,6 +5,7 @@ const View = require("./View.js")
 const Action = require("./Action.js")
 const EventHandler = require("./EventHandler.js")
 const TriggerHandler = require("./TriggerHandler.js")
+const ExecutionQueue = require("../utils/ExecutionQueue.js")
 
 class Service {
 
@@ -13,6 +14,8 @@ class Service {
     this.app = app
     this.name = definition.name
 
+    if(app.shortEvents) this.eventQueue = new ExecutionQueue()
+
     this.profileLog = app.profileLog
 
     this.dao = definition.daoFactory ? definition.daoFactory(app) : app.dao

package/lib/updaters/database.js

@@ -5,23 +5,30 @@ async function update(changes, service, app, force) {
   const dao = app.dao
   const database = app.databaseName
 
-  dao.request(['database', 'createTable'], database, 'eventConsumers').catch(e => 'ok')
-  dao.request(['database', 'createTable'], database, 'triggerRoutes').catch(e => 'ok')
-  dao.request(['database', 'createTable'], database, 'eventReports').catch(e => 'ok')
-  if(app.splitEvents) {
-    dao.request(['database', 'createLog'], database, service.name+'_events').catch(e => 'ok')
-  } else {
-    dao.request(['database', 'createLog'], database, 'events').catch(e => 'ok')
+  if(!app.shortEvents) {
+    dao.request(['database', 'createTable'], database, 'eventConsumers').catch(e => 'ok')
+    dao.request(['database', 'createTable'], database, 'eventReports').catch(e => 'ok')
+    if (app.splitEvents) {
+      dao.request(['database', 'createLog'], database, service.name + '_events').catch(e => 'ok')
+    } else {
+      dao.request(['database', 'createLog'], database, 'events').catch(e => 'ok')
+    }
   }
-  if(app.splitCommands) {
-    dao.request(['database', 'createTable'], database, service.name+'_commands').catch(e => 'ok')
-  } else {
-    dao.request(['database', 'createTable'], database, 'commands').catch(e => 'ok')
+
+  if(!app.shortCommands) {
+    if (app.splitCommands) {
+      dao.request(['database', 'createTable'], database, service.name + '_commands').catch(e => 'ok')
+    } else {
+      dao.request(['database', 'createTable'], database, 'commands').catch(e => 'ok')
+    }
   }
-  if(app.splitTriggers) {
-    dao.request(['database', 'createTable'], database, service.name+'_triggers').catch(e => 'ok')
-  } else {
-    dao.request(['database', 'createTable'], database, 'triggers').catch(e => 'ok')
+  if(!app.shortTriggers) {
+    dao.request(['database', 'createTable'], database, 'triggerRoutes').catch(e => 'ok')
+    if (app.splitTriggers) {
+      dao.request(['database', 'createTable'], database, service.name + '_triggers').catch(e => 'ok')
+    } else {
+      dao.request(['database', 'createTable'], database, 'triggers').catch(e => 'ok')
+    }
   }
 
   const generateTableName = (modelName) => {
@@ -47,7 +54,7 @@ async function update(changes, service, app, force) {
 
     if(index.function) {
       await dao.request(['database', 'createIndex'], database, indexName,
-          `(${index.function})`, { ...(index.parameters || {}) })
+          `(${index.function})`, { ...(index.parameters || {}) }, index.storage ?? {})
     } else {
       if(!table) throw new Error("only function indexes are possible without table")
       if(index.multi) {
@@ -78,7 +85,7 @@ async function update(changes, service, app, force) {
                 }
               })
             }
-        })`, { property: index.property.split('.'), table })
+        })`, { property: index.property.split('.'), table }, index.storage ?? {})
       } else {
         if(!table) throw new Error("only function indexes are possible without table")
         const properties = (Array.isArray(index.property) ? index.property : [index.property]).map(p => p.split('.'))
@@ -95,7 +102,7 @@ async function update(changes, service, app, force) {
               await input.table(table).onChange((obj, oldObj) =>
                   output.change(obj && mapper(obj), oldObj && mapper(oldObj)) )
             }
-        })`, { properties, table })
+        })`, { properties, table }, index.storage ?? {})
       }
     }
 
@@ -110,7 +117,7 @@ async function update(changes, service, app, force) {
       case "createModel": {
         const model = change.model
         const tableName = generateTableName(model.name)
-        await dao.request(['database', 'createTable'], database, tableName)
+        await dao.request(['database', 'createTable'], database, tableName, model.storage ?? {})
         debug("TABLE CREATED!", tableName)
         for(let indexName in model.indexes) {
           const index = model.indexes[indexName]
@@ -154,7 +161,7 @@ async function update(changes, service, app, force) {
       case "createIndex": {
         const table = change.model ? generateTableName(change.model) : null
         const index = change.index
-        await createIndex(table, change.name, index)
+        await createIndex(table, change.name, index, change.model)
       } break
       case "renameIndex": {
         const table = change.model ? generateTableName(change.model) : null

package/lib/utils/CommandQueue.js

@@ -1,12 +1,13 @@
 const ReactiveDao = require('@live-change/dao')
 
 class CommandQueue {
-  constructor(connection, database, tableName, serviceName) {
+  constructor(connection, database, tableName, serviceName, config) {
     this.connection = connection
     this.database = database
     this.tableName = tableName
     this.indexName = tableName + '_new'
     this.serviceName = serviceName
+    this.config = config || {}
     this.observable = null
     this.disposed = false
     this.resolveStart = null
@@ -22,8 +23,10 @@ class CommandQueue {
     }
   }
   async start() {
+    console.log("START COMMAND QUEUE", this.database, this.tableName, this.indexName, this.config)
     //console.log("START QUEUE", this.tableName, this.indexName)
-    await this.connection.request(['database', 'createTable'], this.database, this.tableName).catch(e => 'ok')
+    await this.connection.request(['database', 'createTable'], this.database, this.tableName,
+      this.config.storage ?? {}).catch(e => 'ok')
     await this.connection.request(['database', 'createIndex'], this.database, this.indexName, `(${
         async function(input, output, { tableName }) {
           await input.table(tableName).onChange(async (obj, oldObj) => {
@@ -33,7 +36,7 @@ class CommandQueue {
             await output.change(res, oldRes)
           })
         }
-    })`, { tableName: this.tableName }).catch(e => 'ok')
+    })`, { tableName: this.tableName }, this.config.storage ?? {}).catch(e => 'ok')
     this.observable = this.connection.observable(
         ['database', 'indexRange', this.database, this.indexName, {
           gt: this.serviceName+'_',

package/lib/utils/EventSourcing.js

@@ -25,8 +25,10 @@ class EventSourcing {
     await this.saveState()
   }
   async start() {
-    await this.connection.request(['database', 'createTable'], this.database, 'eventConsumers').catch(e => 'ok')
-    await this.connection.request(['database', 'createLog'], this.database, this.logName).catch(e => 'ok')
+    await this.connection.request(['database', 'createTable'], this.database, 'eventConsumers', this.config.storage ?? {})
+      .catch(e => 'ok')
+    await this.connection.request(['database', 'createLog'], this.database, this.logName, this.config.storage ?? {})
+      .catch(e => 'ok')
     this.state = await this.connection.get(
         ['database', 'tableObject', this.database, 'eventConsumers', this.consumerId])
     //console.log("GOT CONSUMER STATE", this.state)

package/lib/utils/ExecutionQueue.js

@@ -30,7 +30,7 @@ class ExecutionQueue {
   runNext() {
     if(this.nextRoutines.length == 0) {
       this.running = false
-      setTimeout(() => { if(!this.running) this.queues.delete(this.key) }, 500)
+      setTimeout(() => { if(!this.running && this.queues) this.queues.delete(this.key) }, 500)
       return;
     }
     this.running = true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/framework",
-  "version": "0.7.18",
+  "version": "0.7.19",
   "description": "Live Change Framework - ultimate solution for real time mobile/web apps",
   "main": "index.js",
   "scripts": {
@@ -21,13 +21,13 @@
   },
   "homepage": "https://github.com/live-change/live-change-framework",
   "devDependencies": {
-    "@live-change/dao": "^0.5.10",
-    "@live-change/dao-websocket": "^0.5.10",
-    "@live-change/db": "^0.5.25",
-    "@live-change/db-store-level": "^0.5.25",
-    "@live-change/db-store-lmdb": "^0.5.25",
-    "@live-change/sockjs": "^0.4.1",
-    "@live-change/uid": "^0.7.18",
+    "@live-change/dao": "0.5.15",
+    "@live-change/dao-websocket": "0.5.15",
+    "@live-change/db": "0.6.3",
+    "@live-change/db-store-level": "0.6.3",
+    "@live-change/db-store-lmdb": "0.6.3",
+    "@live-change/sockjs": "0.4.1",
+    "@live-change/uid": "0.7.18",
     "cookie": "^0.4.1",
     "express": "^4.18.1",
     "os-service": "^2.2.0",
@@ -35,5 +35,5 @@
     "tape": "^5.3.2",
     "websocket": "^1.0.34"
   },
-  "gitHead": "5916995dc07ad8f25ae983d20e45dc4365300386"
+  "gitHead": "bc09aeeb64724fdfcf4e944d1858a2a00f08edcc"
 }