@live-change/framework 0.4.42 → 0.5.1

package/legacy-env-config.js

@@ -0,0 +1,14 @@
+
+function legacyEnvConfig(env = process.env) {
+  return {
+    db: {
+      url: env.DB_URL,
+      name: env.DB_NAME,
+      requestTimeout: (+env.DB_REQUEST_TIMEOUT),
+      cache: env.DB_CACHE == "YES",
+      //unobserveDebug: env.UNOBSERVE_DEBUG == "YES",
+    }
+  }
+}
+
+module.exports = legacyEnvConfig

package/lib/App.js

@@ -1,7 +1,6 @@
-const crypto = require("crypto")
+const { uidGenerator, randomString } = require('@live-change/uid')
 
 const ReactiveDao = require("@live-change/dao")
-const ReactiveDaoWebsocket = require("@live-change/dao-websocket")
 
 const ServiceDefinition = require("./definition/ServiceDefinition.js")
 
@@ -28,65 +27,52 @@ const databaseUpdater = require("./updaters/database.js")
 const accessControlFilter = require("./clientSideFilters/accessControlFilter.js")
 const clientSideFilter = require("./clientSideFilters/clientSideFilter.js")
 
+const commandExecutor = require("./processes/commandExecutor.js")
+const triggerExecutor = require("./processes/triggerExecutor.js")
+const eventListener = require('./processes/eventListener.js')
+
 const utils = require('./utils.js')
 
 class App {
 
-  constructor(env = process.env, config = {}) {
-    this.env = env
+  constructor(config = {}) {
     this.config = config
     this.splitEvents = false
 
-    this.requestTimeout = (+env.DB_REQUEST_TIMEOUT) || 10*1000
+    this.requestTimeout = config?.db?.requestTimeout || 10*1000
 
     this.defaultProcessors = [
-        crudGenerator,
-        draftGenerator,
-        reverseRelationProcessor,
-        indexListProcessor,
-        daoPathView,
-        fetchView,
-        accessControl,
-        autoValidation,
-        indexCode
+      crudGenerator,
+      draftGenerator,
+      reverseRelationProcessor,
+      indexListProcessor,
+      daoPathView,
+      fetchView,
+      accessControl,
+      autoValidation,
+      indexCode
     ]
     this.defaultUpdaters = [
-        databaseUpdater
+      databaseUpdater
     ]
     this.defaultClientSideFilters = [
-        accessControlFilter,
-        clientSideFilter
+      accessControlFilter,
+      clientSideFilter
+    ]
+    this.defaultProcesses = [
+      commandExecutor,
+      triggerExecutor,
+      eventListener
     ]
-    const dbDao = new ReactiveDao(process.cwd()+' '+process.argv.join(' '), {
-      remoteUrl: env.DB_URL || "http://localhost:9417/api/ws",
-      protocols: {
-        'ws': ReactiveDaoWebsocket.client
-      },
-      connectionSettings: {
-        queueRequestsWhenDisconnected: true,
-        requestSendTimeout: 2000,
-        requestTimeout: this.requestTimeout,
-        queueActiveRequestsOnDisconnect: false,
-        autoReconnectDelay: 200,
-        logLevel: 1,
-        unobserveDebug: env.UNOBSERVE_DEBUG == "YES"
-      },
-      database: {
-        type: 'remote',
-        generator: ReactiveDao.ObservableList
-      },
-      store: {
-        type: 'remote',
-        generator: ReactiveDao.ObservableList
-      }
-    })
 
-    this.dao = dbDao
-    if(process.env.DB_CACHE == "YES") this.dao = new ReactiveDao.DaoCache(dbDao)
+    this.dao = null
 
     this.profileLog = profileLog
 
-    this.databaseName = env.DB_NAME || 'test'
+    this.databaseName = config?.db?.name || 'test'
+
+    this.instanceId = randomString(4)
+    this.uidGenerator = uidGenerator(this.instanceId)
   }
 
   createServiceDefinition( definition ) {
@@ -137,7 +123,8 @@ class App {
     await this.profileLog.end(profileOp)
   }
 
-  async startService( serviceDefinition, config ) {
+  async startService( serviceDefinition, config = {}) {
+    if(!config.processes) config.processes = this.defaultProcesses
     console.log("Starting service", serviceDefinition.name, "!")
     const profileOp = await this.profileLog.begin({
       operation: "startService", serviceName: serviceDefinition.name, config
@@ -145,7 +132,7 @@ class App {
     if(!(serviceDefinition instanceof ServiceDefinition))
       serviceDefinition = new ServiceDefinition(serviceDefinition)
     let service = new Service(serviceDefinition, this)
-    await service.start(config || {})
+    await service.start(config)
     console.log("service started", serviceDefinition.name, "!")
     await this.profileLog.end(profileOp)
     return service
@@ -164,7 +151,7 @@ class App {
   }
 
   generateUid() {
-    return crypto.randomBytes(16).toString("hex")
+    return this.uidGenerator()
   }
 
   async clientSideDefinition( service, client, filters ) {

package/lib/processes/commandExecutor.js

@@ -0,0 +1,74 @@
+const KeyBasedExecutionQueues = require('../utils/KeyBasedExecutionQueues.js')
+const CommandQueue = require('../utils/CommandQueue.js')
+const SingleEmitQueue = require('../utils/SingleEmitQueue.js')
+const SplitEmitQueue = require('../utils/SplitEmitQueue.js')
+
+async function startCommandExecutor(service, config) {
+  if(!config.runCommands) return
+
+  service.keyBasedExecutionQueues = service.keyBasedExecutionQueues || new KeyBasedExecutionQueues(r => r.key)
+  
+  service.commandQueue = new CommandQueue(service.dao, service.databaseName,
+      service.app.splitCommands ? `${service.name}_commands` : 'commands', service.name)
+  for (let actionName in service.actions) {
+    const action = service.actions[actionName]
+    if (action.definition.queuedBy) {
+      const queuedBy = action.definition.queuedBy
+      const keyFunction = typeof queuedBy == 'function' ? queuedBy : (
+          Array.isArray(queuedBy) ? (c) => JSON.stringify(queuedBy.map(k => c[k])) :
+              (c) => JSON.stringify(c[queuedBy]))
+      service.commandQueue.addCommandHandler(actionName, async (command) => {
+        const profileOp = await service.profileLog.begin({
+          operation: 'queueCommand', commandType: actionName,
+          commandId: command.id, client: command.client
+        })
+        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 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)
+          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 {
+      service.commandQueue.addCommandHandler(actionName,
+          (command) => service.profileLog.profile({
+            operation: 'runCommand', commandType: actionName,
+            commandId: command.id, client: command.client
+          }, 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 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)
+            return result
+          })
+      )
+
+    }
+  }
+
+  service.commandQueue.start()
+}
+
+module.exports = startCommandExecutor

package/lib/processes/eventListener.js

@@ -0,0 +1,40 @@
+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 })
+  } else {
+    service.eventSourcing = new EventSourcing(service.dao, service.databaseName,
+        'events', service.name,
+        { filter: (event) => event.service == service.name })
+  }
+
+
+  for (let eventName in service.events) {
+    const event = service.events[eventName]
+    service.eventSourcing.addEventHandler(eventName, async (ev, bucket) => {
+      return await service.profileLog.profile({ operation: "handleEvent", eventName, id: ev.id,
+            bucketId: bucket.id, triggerId: bucket.triggerId, commandId: bucket.commandId },
+          () => {
+            console.log("EXECUTING EVENT", ev)
+            return event.execute(ev, bucket)
+          }
+      )
+    })
+    service.eventSourcing.onBucketEnd = async (bucket, handledEvents) => {
+      if(bucket.reportFinished && handledEvents.length > 0) {
+        await service.dao.request(['database', 'update'], service.databaseName, 'eventReports', bucket.reportFinished,[
+          { op: "mergeSets", property: 'finished', values: handledEvents.map(ev => ({ id: ev.id, type: ev.type })) }
+        ])
+      }
+    }
+  }
+
+  service.eventSourcing.start()
+}
+
+module.exports = startEventListener

package/lib/processes/triggerExecutor.js

@@ -0,0 +1,93 @@
+const KeyBasedExecutionQueues = require('../utils/KeyBasedExecutionQueues.js')
+const CommandQueue = require('../utils/CommandQueue.js')
+const SingleEmitQueue = require('../utils/SingleEmitQueue.js')
+const SplitEmitQueue = require('../utils/SplitEmitQueue.js')
+
+async function startTriggerExecutor(service, config) {
+  if(!config.runCommands) return
+  
+  service.keyBasedExecutionQueues = service.keyBasedExecutionQueues || new KeyBasedExecutionQueues(r => r.key)
+
+  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 )
+  for (let triggerName in service.triggers) {
+    const trigger = service.triggers[triggerName]
+    await service.dao.request(['database', 'put'], service.databaseName, 'triggerRoutes',
+        { id: triggerName + '=>' + service.name, trigger: triggerName, service: service.name })
+    if(trigger.definition.queuedBy) {
+      const queuedBy = trigger.definition.queuedBy
+      const keyFunction = typeof queuedBy == 'function' ? queuedBy : (
+          Array.isArray(queuedBy) ? (c) => JSON.stringify(queuedBy.map(k=>c[k])) :
+              (c) => JSON.stringify(c[queuedBy]) )
+      service.triggerQueue.addCommandHandler(triggerName, async (trig) => {
+        const profileOp = await service.profileLog.begin({ operation: 'queueTrigger', triggerType: triggerName,
+          triggerId: trig.id, by: trig.by })
+        console.log("QUEUED TRIGGER STARTED", trig)
+        const reportFinished = trigger.definition.waitForEvents ? 'trigger_'+trig.id : undefined
+        const flags = { triggerId: trig.id, reportFinished }
+        const emit = service.app.splitEvents
+            ? new SplitEmitQueue(service, flags)
+            : new SingleEmitQueue(service, flags)
+        const routine = () => service.profileLog.profile({ operation: 'runTrigger', triggerType: triggerName,
+          commandId: trig.id, by: trig.by }, async () => {
+          let result
+          try {
+            console.log("TRIGGERED!!", trig)
+            result = await service.app.assertTime('trigger '+trigger.definition.name,
+                trigger.definition.timeout || 10000,
+                () => trigger.execute(trig, (...args) => emit.emit(...args)), trig)
+            console.log("TRIGGER DONE!", trig)
+          } catch (e) {
+            console.error(`TRIGGER ${triggerName} ERROR`, e.stack)
+            throw e
+          }
+          const events = await emit.commit()
+          if(trigger.definition.waitForEvents)
+            await service.app.waitForEvents(reportFinished, events, trigger.definition.waitForEvents)
+          return result
+        })
+        try {
+          routine.key = keyFunction(trig)
+        } catch(e) {
+          console.error("QUEUE KEY FUNCTION ERROR", e)
+        }
+        console.log("TRIGGER QUEUE KEY", routine.key)
+        const promise = service.keyBasedExecutionQueues.queue(routine)
+        await service.profileLog.endPromise(profileOp, promise)
+        return promise
+      })
+    } else {
+      service.triggerQueue.addCommandHandler(triggerName,
+          (trig) => service.profileLog.profile({ operation: 'runTrigger', triggerType: triggerName,
+            commandId: trig.id, by: trig.by }, async () => {
+            console.log("NOT QUEUED TRIGGER STARTED", trig)
+            const reportFinished = trigger.definition.waitForEvents ? 'trigger_'+trig.id : undefined
+            const flags = { triggerId: trig.id, reportFinished }
+            const emit = service.app.splitEvents
+                ? new SplitEmitQueue(service, flags)
+                : new SingleEmitQueue(service, flags)
+            let result
+            try {
+              result = await service.app.assertTime('trigger '+trigger.definition.name,
+                  trigger.definition.timeout || 10000,
+                  () => trigger.execute(trig, (...args) => emit.emit(...args)), trig)
+              console.log("TRIGGER DONE!", trig)
+            } catch (e) {
+              console.error(`TRIGGER ${triggerName} ERROR`, e.stack)
+              throw e
+            }
+            const events = await emit.commit()
+            if(trigger.definition.waitForEvents)
+              await service.app.waitForEvents(reportFinished, events, trigger.definition.waitForEvents)
+            return result
+          })
+      )
+    }
+  }
+
+  service.triggerQueue.start()
+}
+
+module.exports = startTriggerExecutor

package/lib/runtime/Dao.js

@@ -38,7 +38,7 @@ function prepareReactiveDaoDefinition(config, clientData) {
       }
       for(let viewName in service.views) {
         let view = service.views[viewName]
-        if(process.env.PROFILE_READS == "YES") {
+        if(config.profileReads) {
           values[viewName] = {
             async observable(parameters) {
               const observable = await view.observable(parameters, clientData)

package/lib/runtime/Service.js

@@ -5,12 +5,6 @@ const View = require("./View.js")
 const Action = require("./Action.js")
 const EventHandler = require("./EventHandler.js")
 const TriggerHandler = require("./TriggerHandler.js")
-const SearchIndexer = require("./SearchIndexer.js")
-const ReactiveDao = require("@live-change/dao")
-
-const EventSourcing = require('../utils/EventSourcing.js')
-const CommandQueue = require('../utils/CommandQueue.js')
-const KeyBasedExecutionQueues = require('../utils/KeyBasedExecutionQueues.js')
 
 class Service {
 
@@ -79,11 +73,7 @@ class Service {
     //console.log("DEFN", this.definition)
     //console.log("DEFN JSON", JSON.stringify(this.definition.toJSON(), null, "  "))
 
-    let promises = []
-    if(config.runCommands) promises.push(this.startCommandExecutor())
-    if(config.handleEvents) promises.push(this.startEventListener())
-    if(config.indexSearch) promises.push(this.startSearchIndexer())
-
+    let promises = config.processes.map(proc => proc(this, config))
     await Promise.all(promises)
 
     //if(config.startEventListener) this.startEventListener()
@@ -99,335 +89,7 @@ class Service {
     return this.app.triggerService(service, data)
   }
 
-  async startEventListener() {
-    if(this.app.splitEvents) {
-      this.eventSourcing = new EventSourcing(this.dao, this.databaseName,
-          'events_'+this.name, this.name,
-          { filter: (event) => event.service == this.name })
-    } else {
-      this.eventSourcing = new EventSourcing(this.dao, this.databaseName,
-          'events', this.name,
-          { filter: (event) => event.service == this.name })
-    }
-
-
-    for (let eventName in this.events) {
-      const event = this.events[eventName]
-      this.eventSourcing.addEventHandler(eventName, async (ev, bucket) => {
-        return await this.profileLog.profile({ operation: "handleEvent", eventName, id: ev.id,
-          bucketId: bucket.id, triggerId: bucket.triggerId, commandId: bucket.commandId },
-            () => {
-              console.log("EXECUTING EVENT", ev)
-              return event.execute(ev, bucket)
-            }
-        )
-      })
-      this.eventSourcing.onBucketEnd = async (bucket, handledEvents) => {
-        if(bucket.reportFinished && handledEvents.length > 0) {
-          await this.dao.request(['database', 'update'], this.databaseName, 'eventReports', bucket.reportFinished,[
-            { op: "mergeSets", property: 'finished', values: handledEvents.map(ev => ({ id: ev.id, type: ev.type })) }
-          ])
-        }
-      }
-    }
-
-    this.eventSourcing.start()
-  }
-
-  async startCommandExecutor() {
-    this.commandQueue = new CommandQueue(this.dao, this.databaseName,
-        this.app.splitCommands ? `${this.name}_commands` : 'commands', this.name)
-    this.keyBasedCommandQueues = new KeyBasedExecutionQueues(r => r.key)
-    for (let actionName in this.actions) {
-      const action = this.actions[actionName]
-      if(action.definition.queuedBy) {
-        const queuedBy = action.definition.queuedBy
-        const keyFunction = typeof queuedBy == 'function' ? queuedBy : (
-            Array.isArray(queuedBy) ? (c) => JSON.stringify(queuedBy.map(k=>c[k])) :
-                (c) => JSON.stringify(c[queuedBy]) )
-        this.commandQueue.addCommandHandler(actionName, async (command) => {
-          const profileOp = await this.profileLog.begin({ operation: 'queueCommand', commandType: actionName,
-            commandId: command.id, client: command.client })
-          const reportFinished = action.definition.waitForEvents ? 'command_'+command.id : undefined
-          const flags = { commandId: command.id, reportFinished }
-          const emit = this.app.splitEvents
-              ? new SplitEmitQueue(this, flags)
-              : new SingleEmitQueue(this, flags)
-          const routine = () => this.profileLog.profile({ operation: 'runCommand', commandType: actionName,
-            commandId: command.id, client: command.client }, async () => {
-              const result = await this.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 this.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
-              return result
-            })
-          routine.key = keyFunction(command)
-          const promise = this.keyBasedCommandQueues.queue(routine)
-          await this.profileLog.endPromise(profileOp, promise)
-          return promise
-        })
-      } else {
-        this.commandQueue.addCommandHandler(actionName,
-            (command) => this.profileLog.profile({ operation: 'runCommand', commandType: actionName,
-              commandId: command.id, client: command.client }, async () => {
-            const reportFinished = action.definition.waitForEvents ? 'command_'+command.id : undefined
-            const flags = { commandId: command.id, reportFinished }
-            const emit = this.app.splitEvents
-                ? new SplitEmitQueue(this, flags)
-                : new SingleEmitQueue(this, flags)
-            const result = await this.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 this.app.waitForEvents(reportFinished, events, action.definition.waitForEvents)
-            return result
-          })
-        )
-
-      }
-    }
-
-    await this.dao.request(['database', 'createTable'], this.databaseName, 'triggerRoutes').catch(e => 'ok')
-
-    this.triggerQueue = new CommandQueue(this.dao, this.databaseName,
-        this.app.splitTriggers ? `${this.name}_triggers` : 'triggers', this.name )
-    this.keyBasedTriggerQueues = new KeyBasedExecutionQueues(r => r.key)
-    for (let triggerName in this.triggers) {
-      const trigger = this.triggers[triggerName]
-      await this.dao.request(['database', 'put'], this.databaseName, 'triggerRoutes',
-          { id: triggerName + '=>' + this.name, trigger: triggerName, service: this.name })
-      if(trigger.definition.queuedBy) {
-        const queuedBy = trigger.definition.queuedBy
-        const keyFunction = typeof queuedBy == 'function' ? queuedBy : (
-            Array.isArray(queuedBy) ? (c) => JSON.stringify(queuedBy.map(k=>c[k])) :
-                (c) => JSON.stringify(c[queuedBy]) )
-        this.triggerQueue.addCommandHandler(triggerName, async (trig) => {
-          const profileOp = await this.profileLog.begin({ operation: 'queueTrigger', triggerType: triggerName,
-            triggerId: trig.id, by: trig.by })
-          console.log("QUEUED TRIGGER STARTED", trig)
-          const reportFinished = trigger.definition.waitForEvents ? 'trigger_'+trig.id : undefined
-          const flags = { triggerId: trig.id, reportFinished }
-          const emit = this.app.splitEvents
-              ? new SplitEmitQueue(this, flags)
-              : new SingleEmitQueue(this, flags)
-          const routine = () => this.profileLog.profile({ operation: 'runTrigger', triggerType: triggerName,
-            commandId: trig.id, by: trig.by }, async () => {
-              let result
-              try {
-                console.log("TRIGGERED!!", trig)
-                result = await this.app.assertTime('trigger '+trigger.definition.name,
-                    trigger.definition.timeout || 10000,
-                    () => trigger.execute(trig, (...args) => emit.emit(...args)), trig)
-                console.log("TRIGGER DONE!", trig)
-              } catch (e) {
-                console.error(`TRIGGER ${triggerName} ERROR`, e.stack)
-                throw e
-              }
-              const events = await emit.commit()
-              if(trigger.definition.waitForEvents)
-                await this.app.waitForEvents(reportFinished, events, trigger.definition.waitForEvents)
-              return result
-            })
-          try {
-            routine.key = keyFunction(trig)
-          } catch(e) {
-            console.error("QUEUE KEY FUNCTION ERROR", e)
-          }
-          console.log("TRIGGER QUEUE KEY", routine.key)
-          const promise = this.keyBasedTriggerQueues.queue(routine)
-          await this.profileLog.endPromise(profileOp, promise)
-          return promise
-        })
-      } else {
-        this.triggerQueue.addCommandHandler(triggerName,
-        (trig) => this.profileLog.profile({ operation: 'runTrigger', triggerType: triggerName,
-          commandId: trig.id, by: trig.by }, async () => {
-            console.log("NOT QUEUED TRIGGER STARTED", trig)
-            const reportFinished = trigger.definition.waitForEvents ? 'trigger_'+trig.id : undefined
-            const flags = { triggerId: trig.id, reportFinished }
-            const emit = this.app.splitEvents
-                ? new SplitEmitQueue(this, flags)
-                : new SingleEmitQueue(this, flags)
-            let result
-            try {
-              result = await this.app.assertTime('trigger '+trigger.definition.name,
-                  trigger.definition.timeout || 10000,
-                  () => trigger.execute(trig, (...args) => emit.emit(...args)), trig)
-              console.log("TRIGGER DONE!", trig)
-            } catch (e) {
-              console.error(`TRIGGER ${triggerName} ERROR`, e.stack)
-              throw e
-            }
-            const events = await emit.commit()
-            if(trigger.definition.waitForEvents)
-              await this.app.waitForEvents(reportFinished, events, trigger.definition.waitForEvents)
-            return result
-          })
-        )
-      }
-    }
-
-    this.commandQueue.start()
-    this.triggerQueue.start()
-  }
-
-  async startSearchIndexer() {
-    let anyIndex = false
-    for(const name in this.models) if(this.models[name].definition.searchIndex) anyIndex = true
-    for(const name in this.indexes) if(this.indexes[name].definition.searchIndex) anyIndex = true
-    if(!anyIndex) {
-      console.log("not starting search indexer - nothing to index!")
-      return
-    }
-    console.log("starting search indexer!")
-    await this.dao.request(['database', 'createTable'], this.databaseName, 'searchIndexes').catch(e => 'ok')
-
-    this.searchIndexers = []
-
-    const elasticsearch = this.app.connectToSearch()
-
-    for(const modelName in this.models) {
-      const model = this.models[modelName]
-      const indexName = model.definition.searchIndex
-      if(!indexName) continue
-      const indexer = new SearchIndexer(
-          this.dao, this.databaseName, 'Table', model.tableName, elasticsearch, indexName, model.definition
-      )
-      this.searchIndexers.push(indexer)
-    }
-
-    for(const indexName in this.indexes) {
-      const index = this.indexes[indexName]
-      const indexName = index.definition.searchIndex
-      if(!indexName) continue
-      const indexer = new SearchIndexer(
-          this.dao, this.databaseName, 'Index', model.tableName, elasticsearch, indexName, index.definition
-      )
-      this.searchIndexers.push(indexer)
-    }
-
-    const promises = []
-    for(const searchIndexer of this.searchIndexers) {
-      promises.push(this.profileLog.profile({
-        operation: "startIndexer", serviceName: this.name, indexName: searchIndexer.indexName
-      }, () => searchIndexer.start()))
-    }
-    await Promise.all(promises)
-    console.log("search indexer started!")
-  }
-
 }
 
-class SplitEmitQueue {
-  constructor(service, flags = {}) {
-    this.service = service
-    this.flags = flags
-    this.emittedEvents = new Map()
-    this.commited = false
-  }
-
-  emit(service, event) {
-    if(!event) {
-      event = service
-      if(Array.isArray(event)) {
-        let hasServices = false
-        for(let ev of event) {
-          if(ev.service) hasServices = true
-        }
-        if(hasServices) {
-          for(let ev of event) {
-            this.emit(ev)
-          }
-          return
-        }
-      } else {
-        service = event.service || this.service.name
-      }
-    }
-    let events
-    if(!this.commited) {
-      events = this.emittedEvents.get(service)
-      if(!events) {
-        events = []
-        this.emittedEvents.set(service, events)
-      }
-    } else {
-      events = []
-    }
-    if(Array.isArray(event)) {
-      for(let ev of event) ev.service = service
-      events.push(...event)
-    } else {
-      event.service = service
-      events.push(event)
-    }
-    if(this.commited) {
-      if(events.length == 0) return
-      this.service.dao.request(['database', 'putLog'], this.service.databaseName,
-          this.service.name+'_events', { type: 'bucket', events, ...this.flags })
-    }
-  }
-
-  async commit() {
-    let promises = []
-    this.commited = true
-    if(this.emittedEvents.length == 0) return []
-    let allEvents = []
-    for(const [service, events] of this.emittedEvents.keys()) {
-      promises.push(this.service.dao.request(['database', 'putLog'], this.service.databaseName,
-          this.service.name+'_events', { type: 'bucket', events, ...this.flags }))
-      allEvents.push(...events)
-    }
-    await Promise.all(promises)
-    return allEvents
-  }
-}
-
-class SingleEmitQueue {
-  constructor(service, flags = {}) {
-    this.service = service
-    this.flags = flags
-    this.emittedEvents = []
-    this.commited = false
-  }
-
-  emit(service, event) {
-    if(!event) {
-      event = service
-      service = this.service.name
-    }
-    let events
-    if(!this.commited) {
-      events = this.emittedEvents
-    } else {
-      events = []
-    }
-    if(Array.isArray(event)) {
-      for(let ev of event) if(!ev.service) ev.service = service
-      events.push(...event)
-    } else {
-      if(!event.service) event.service = service
-      events.push(event)
-    }
-    if(this.commited) {
-      if(events.length == 0) return
-      this.service.dao.request(['database', 'putLog'], this.service.databaseName,
-          'events', { type: 'bucket', events, ...this.flags })
-    }
-  }
-
-  async commit() {
-    this.commited = true
-    if(this.emittedEvents.length == 0) return []
-    await this.service.dao.request(['database', 'putLog'], this.service.databaseName,
-          'events', { type: 'bucket', events: this.emittedEvents, ...this.flags })
-    return this.emittedEvents
-  }
-}
-
-
 
 module.exports = Service

package/lib/utils/EventSourcing.js

@@ -78,7 +78,7 @@ class EventSourcing {
     if (this.config.filter && !this.config.filter(event)) return []
     let done = false
     let retry = 0
-    const maxRetry = process.env.MAX_EVENT_RETRY_COUNT || 10
+    const maxRetry = this.config.maxRetryCount || 10
     while(!done && maxRetry) {
       try {
         await this.doHandleEvent(event, mainEvent)

package/lib/utils/SingleEmitQueue.js

@@ -0,0 +1,44 @@
+
+class SingleEmitQueue {
+  constructor(service, flags = {}) {
+    this.service = service
+    this.flags = flags
+    this.emittedEvents = []
+    this.commited = false
+  }
+
+  emit(service, event) {
+    if(!event) {
+      event = service
+      service = this.service.name
+    }
+    let events
+    if(!this.commited) {
+      events = this.emittedEvents
+    } else {
+      events = []
+    }
+    if(Array.isArray(event)) {
+      for(let ev of event) if(!ev.service) ev.service = service
+      events.push(...event)
+    } else {
+      if(!event.service) event.service = service
+      events.push(event)
+    }
+    if(this.commited) {
+      if(events.length == 0) return
+      this.service.dao.request(['database', 'putLog'], this.service.databaseName,
+          'events', { type: 'bucket', events, ...this.flags })
+    }
+  }
+
+  async commit() {
+    this.commited = true
+    if(this.emittedEvents.length == 0) return []
+    await this.service.dao.request(['database', 'putLog'], this.service.databaseName,
+          'events', { type: 'bucket', events: this.emittedEvents, ...this.flags })
+    return this.emittedEvents
+  }
+}
+
+module.exports = SingleEmitQueue

package/lib/utils/SplitEmitQueue.js

@@ -0,0 +1,67 @@
+
+class SplitEmitQueue {
+  constructor(service, flags = {}) {
+    this.service = service
+    this.flags = flags
+    this.emittedEvents = new Map()
+    this.commited = false
+  }
+
+  emit(service, event) {
+    if(!event) {
+      event = service
+      if(Array.isArray(event)) {
+        let hasServices = false
+        for(let ev of event) {
+          if(ev.service) hasServices = true
+        }
+        if(hasServices) {
+          for(let ev of event) {
+            this.emit(ev)
+          }
+          return
+        }
+      } else {
+        service = event.service || this.service.name
+      }
+    }
+    let events
+    if(!this.commited) {
+      events = this.emittedEvents.get(service)
+      if(!events) {
+        events = []
+        this.emittedEvents.set(service, events)
+      }
+    } else {
+      events = []
+    }
+    if(Array.isArray(event)) {
+      for(let ev of event) ev.service = service
+      events.push(...event)
+    } else {
+      event.service = service
+      events.push(event)
+    }
+    if(this.commited) {
+      if(events.length == 0) return
+      this.service.dao.request(['database', 'putLog'], this.service.databaseName,
+          this.service.name+'_events', { type: 'bucket', events, ...this.flags })
+    }
+  }
+
+  async commit() {
+    let promises = []
+    this.commited = true
+    if(this.emittedEvents.length == 0) return []
+    let allEvents = []
+    for(const [service, events] of this.emittedEvents.keys()) {
+      promises.push(this.service.dao.request(['database', 'putLog'], this.service.databaseName,
+          this.service.name+'_events', { type: 'bucket', events, ...this.flags }))
+      allEvents.push(...events)
+    }
+    await Promise.all(promises)
+    return allEvents
+  }
+}
+
+module.exports = SplitEmitQueue

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/framework",
-  "version": "0.4.42",
+  "version": "0.5.1",
   "description": "Live Change Framework - ultimate solution for real time mobile/web apps",
   "main": "index.js",
   "scripts": {
@@ -26,6 +26,7 @@
     "@live-change/db": "^0.3.62",
     "@live-change/db-store-level": "^0.1.14",
     "@live-change/db-store-lmdb": "^0.1.21",
+    "@live-change/uid": "^0.1.2",
     "cookie": "^0.4.1",
     "encoding-down": "^7.0.0",
     "express": "^4.17.1",