@live-change/framework 0.7.12 → 0.7.15

package/lib/processes/triggerExecutor.js

@@ -5,7 +5,7 @@ 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')
@@ -13,78 +13,12 @@ async function startTriggerExecutor(service, config) {
   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]
+    const triggers = 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.addCommandHandler(triggerName,
+      (trig) => Promise.all(triggers.map( trigger => trigger.execute(trig, service) ))
+    )
   }
 
   service.triggerQueue.start()

package/lib/runtime/Dao.js

@@ -11,11 +11,12 @@ function prepareReactiveDaoDefinition(config, clientData) {
   if(!clientData.roles) throw new Error("no roles")
   let dao = {}
   if(config.remote) {
-    const remoteList = config.remote(clientData)
-    for (let remote of remoteList) {
-      dao[remote.name] = {
+    const remote = config.remote(clientData)
+    for (let remoteName of remote) {
+      dao[remoteName] = {
         type: "remote",
-        generator: remote.generator || ReactiveDao.ObservableList
+        generator: ReactiveDao.ObservableList,
+        ...remote
       }
     }
   }

package/lib/runtime/Service.js

@@ -52,7 +52,8 @@ class Service {
 
     this.triggers = {}
     for(let triggerName in this.definition.triggers) {
-      this.triggers[triggerName] = new TriggerHandler( this.definition.triggers[triggerName], this )
+      this.triggers[triggerName] = this.definition.triggers[triggerName]
+        .map(trigger => new TriggerHandler( trigger, this ))
     }
 
     this.events = {}

package/lib/runtime/TriggerHandler.js

@@ -1,18 +1,27 @@
 const { prepareParameters, processReturn } = require("./params.js")
+const SplitEmitQueue = require("../utils/SplitEmitQueue.js");
+const SingleEmitQueue = require("../utils/SingleEmitQueue.js");
 
 class TriggerHandler {
 
   constructor(definition, service) {
     this.definition = definition
     this.service = service
+
+    if(definition.queuedBy) {
+      const queuedBy = definition.queuedBy
+      this.queueKeyFunction = typeof queuedBy == 'function' ? queuedBy : (
+        Array.isArray(queuedBy) ? (c) => JSON.stringify(queuedBy.map(k=>c[k])) :
+          (c) => JSON.stringify(c[queuedBy]) )
+    }
   }
 
-  async executeSingleTrigger(definition, parameters, emit) {
+  async doExecute(parameters, emit) {
     //console.log("PARAMETERS", JSON.stringify(parameters), "DEFN", this.definition.properties)
-    const preparedParams = await prepareParameters(parameters, definition.properties, this.service)
+    const preparedParams = await prepareParameters(parameters, this.definition.properties, this.service)
     //console.log("PREP PARAMS", preparedParams)
 
-    let resultPromise = definition.execute({
+    let resultPromise = this.definition.execute({
       ...preparedParams
     }, {
       action: this,
@@ -21,21 +30,82 @@ class TriggerHandler {
     }, emit)
 
     resultPromise = resultPromise.then(async result => {
-      const processedResult = await processReturn(result, definition.returns, this.service)
+      const processedResult = await processReturn(result, this.definition.returns, this.service)
       return processedResult
     })
     resultPromise.catch(error => {
-      console.error(`Trigger ${definition.name} error `, error)
+      console.error(`Trigger ${this.definition.name} error `, error)
     })
     return resultPromise
   }
 
-  async execute(parameters, emit) {
-    const resultsPromises = this.definition.map(defn => this.executeSingleTrigger(defn, parameters, emit))
-    const results = await Promise.all(resultsPromises)
-    return results
+  async execute(trig, service) {
+    console.log("EXECUTE", trig, this.queueKeyFunction)
+    const profileOp = await service.profileLog.begin({
+      operation: 'queueTrigger', triggerType: this.definition.name,
+      triggerId: trig.id, by: trig.by
+    })
+    if(this.queueKeyFunction) {
+      console.log("QUEUED TRIGGER STARTED", trig)
+      const routine = () => service.profileLog.profile({
+        operation: 'runTrigger', triggerType: this.definition.name,
+        commandId: trig.id, by: trig.by
+      }, async () => {
+        let result
+        const reportFinished = this.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)
+        try {
+          console.log("TRIGGER RUNNING!", trig)
+          result = await service.app.assertTime('trigger ' + this.definition.name,
+            this.definition.timeout || 10000,
+            () => this.doExecute(trig, (...args) => emit.emit(...args)))
+          console.log("TRIGGER DONE!", trig)
+        } catch (e) {
+          console.error(`TRIGGER ${this.definition.name} ERROR`, e.stack)
+          throw e
+        }
+        const events = await emit.commit()
+        if (this.definition.waitForEvents)
+          await service.app.waitForEvents(reportFinished, events, this.definition.waitForEvents)
+        return result
+      })
+      try {
+        routine.key = this.queueKeyFunction(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 {
+      console.log("NOT QUEUED TRIGGER STARTED", trig)
+      const reportFinished = this.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 '+this.definition.name,
+          this.definition.timeout || 10000,
+          () => this.doExecute(trig, (...args) => emit.emit(...args)))
+        console.log("TRIGGER DONE!", trig)
+      } catch (e) {
+        console.error(`TRIGGER ${this.definition.name} ERROR`, e.stack)
+        throw e
+      }
+      const events = await emit.commit()
+      if(this.definition.waitForEvents)
+        await service.app.waitForEvents(reportFinished, events, this.definition.waitForEvents)
+      await service.profileLog.end(profileOp)
+      return result
+    }
   }
 
 }
 
-module.exports = TriggerHandler
+module.exports = TriggerHandler

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/framework",
-  "version": "0.7.12",
+  "version": "0.7.15",
   "description": "Live Change Framework - ultimate solution for real time mobile/web apps",
   "main": "index.js",
   "scripts": {
@@ -35,5 +35,5 @@
     "tape": "^5.3.2",
     "websocket": "^1.0.34"
   },
-  "gitHead": "747fead6b948fa2f182d8a4b6913c03d0405f7fd"
+  "gitHead": "9e2d54359edb2619024512f95ba6900734e7b3a1"
 }