@live-change/framework 0.8.145 → 0.8.146

package/lib/App.js

@@ -13,10 +13,7 @@ import SessionDao from "./runtime/SessionDao.js"
 import LiveDao from "./runtime/LiveDao.js"
 import ApiServer from "./runtime/ApiServer.js"
 
-import reverseRelationProcessor from "./processors/reverseRelation.js"
 import indexListProcessor from "./processors/indexList.js"
-//import crudGenerator from "./processors/crudGenerator.js"
-import draftGenerator from "./processors/draftGenerator.js"
 import daoPathView from "./processors/daoPathView.js"
 import fetchView from "./processors/fetchView.js"
 import accessControl from "./processors/accessControl.js"
@@ -51,9 +48,6 @@ class App {
     this.requestTimeout = config?.db?.requestTimeout || 10*1000
 
     this.defaultProcessors = [
-      //  crudGenerator,
-      draftGenerator,
-      reverseRelationProcessor,
       indexListProcessor,
       daoPathView,
       fetchView,

package/lib/definition/PropertyDefinition.js

@@ -13,6 +13,9 @@ class PropertyDefinition {
     if(definition.of) {
       this.of = new PropertyDefinition(definition.of)
     }
+    if(definition.items) {
+      this.items = new PropertyDefinition(definition.items)
+    }
   }
 
   createAndAddProperty(name, definition) {
@@ -36,6 +39,9 @@ class PropertyDefinition {
     if(this.of) {
       json.of = this.of.toJSON()
     }
+    if(this.items) {
+      json.items = this.items.toJSON()
+    }
     
     return json
   }
@@ -43,8 +49,10 @@ class PropertyDefinition {
   computeChanges( oldProperty, params, name) {
     let changes = []
     let typeChanged = false
-    if(typeName(this.type) != typeName(oldProperty.type)) typeChanged = true
-    if((this.of && typeName(this.of.type)) != (oldProperty.of && typeName(oldProperty.of.type)))
+    if(typeName(this.type) !== typeName(oldProperty.type)) typeChanged = true
+    if((this.of && typeName(this.of.type)) !== (oldProperty.of && typeName(oldProperty.of.type)))
+      typeChanged = true
+    if((this.items && typeName(this.items.type)) !== (oldProperty.items && typeName(oldProperty.items.type)))
       typeChanged = true
     if(typeChanged) {
       changes.push({
@@ -54,7 +62,7 @@ class PropertyDefinition {
         ...this
       })
     }
-    if(JSON.stringify(this.search) != JSON.stringify(oldProperty.search)) {
+    if(JSON.stringify(this.search) !== JSON.stringify(oldProperty.search)) {
       changes.push({
         operation: "changePropertySearch",
         ...params,

package/lib/definition/ServiceDefinition.js

@@ -93,6 +93,7 @@ class ServiceDefinition {
   }
 
   model(definition) {
+    if(this.models[definition.name]) throw new Error('model ' + definition.name + ' already exists')
     const model = new ModelDefinition(definition, this.name)
     this.models[model.name] = model
     return createModelProxy(this, model)
@@ -105,6 +106,7 @@ class ServiceDefinition {
   }
 
   index(definition) {
+    if(this.indexes[definition.name]) throw new Error('index ' + definition.name + ' already exists')
     const index = new IndexDefinition(definition)
     this.indexes[index.name] = index
     return createIndexProxy(this, index)
@@ -117,18 +119,21 @@ class ServiceDefinition {
   }
 
   action(definition) {
+    if(this.actions[definition.name]) throw new Error('action ' + definition.name + ' already exists')
     const action = new ActionDefinition(definition)
     this.actions[action.name] = action
     return action
   }
 
   event(definition) {
+    if(this.events[definition.name]) throw new Error('event ' + definition.name + ' already exists')
     const event = new EventDefinition(definition)
     this.events[event.name] = event
     return event
   }
 
   view(definition) {
+    if(this.views[definition.name]) throw new Error('view ' + definition.name + ' already exists')
     const view = new ViewDefinition(definition)
     this.views[view.name] = view
     return view
@@ -168,6 +173,7 @@ class ServiceDefinition {
   }
 
   validator(name, validator) {
+    if(this.validators[name]) throw new Error('validator ' + name + ' already exists')
     this.validators[name] = validator
     console.log("VALIDATOR DEFINED", name, validator)
   }

package/lib/runtime/params.js

@@ -28,8 +28,8 @@ async function prepareParameter(parameter, prop, service) {
   }
   if(prop.type === Array) {
     if(!parameter) return parameter
-    if(!prop.of) return parameter
-    return await Promise.all(parameter.map(item => prepareParameter(item, prop.of, service)))
+    if(!(prop.of || prop.items)) return parameter
+    return await Promise.all(parameter.map(item => prepareParameter(item, (prop.of || prop.items), service)))
   }
   if(prop.type === Date && parameter) {
     return new Date(parameter)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/framework",
-  "version": "0.8.145",
+  "version": "0.8.146",
   "description": "Live Change Framework - ultimate solution for real time mobile/web apps",
   "main": "index.js",
   "scripts": {
@@ -22,8 +22,8 @@
   },
   "homepage": "https://github.com/live-change/live-change-stack",
   "devDependencies": {
-    "@live-change/dao": "^0.8.145",
-    "@live-change/uid": "^0.8.145"
+    "@live-change/dao": "^0.8.146",
+    "@live-change/uid": "^0.8.146"
   },
-  "gitHead": "fadc33dc99f47714c3d40f2ce1b5cdf3f050a70a"
+  "gitHead": "56515185d5021b925e891bce7a0a1842ea7fb67c"
 }

package/lib/processors/crudGenerator.js

@@ -1,206 +0,0 @@
-import * as utils from "../utils.js"
-
-function ignoreValidation(prop) {
-  delete prop.validation
-  if(prop.properties) {
-    for(let propName in prop.properties) {
-      ignoreValidation(prop.properties[propName])
-    }
-  }
-  if(prop.of) {
-    delete ignoreValidation(prop.of)
-  }
-}
-
-export default function(service, app) {
-  if(!service) throw new Error("no service")
-  if(!app) throw new Error("no service")
-  for(let modelName in service.models) {
-    const model = service.models[modelName]
-    if(!model.crud) continue
-    const crud = model.crud
-    const generateId = crud.id || (() => app.generateUid())
-    const options = crud.options || {}
-    const writeOptions = crud.writeOptions || {}
-    const readOptions = crud.readOptions || {}
-    const idName = model.name.slice(0, 1).toLowerCase() + model.name.slice(1)
-    let properties = {}
-    for(let propName in model.properties) {
-      let property = model.properties[propName]
-      let typeName = utils.typeName(property.type)
-      properties[propName] = {
-        ...property,
-        idOnly: !!service.models[typeName] // we need only id of entity, nothing more
-      }
-      if(crud.ignoreValidation) {
-        ignoreValidation(properties[propName])
-      }
-    }
-    let idProp = {}
-    idProp[idName] = {
-      type: model,
-      idOnly: true
-    }
-    function genName(name) {
-      return (crud.prefix || "") + model.name + name
-    }
-    function modelRuntime() {
-      return service._runtime.models[modelName]
-    }
-
-    const defaults = utils.getDefaults(model.properties)
-
-    if(!service.events[genName("Created")]) { // Events:
-      service.event({
-        name: genName("Created"),
-        async execute(props) {
-          console.log("CREATE !!!!")
-          const data = utils.mergeDeep({}, defaults, props.data)
-          console.log("DEFAULTS", JSON.stringify(defaults, null, "  "))
-          console.log(`CREATE ${modelName} WITH DATA ${JSON.stringify(data, null, "  ")}`)
-          await modelRuntime().update(props[idName], { ...data, id: props[idName] })
-        }
-      })
-    }
-    if(!service.actions[genName("Create")]) {
-      service.action({
-        name: genName("Create"),
-        properties,
-        returns: {
-          type: model,
-          idOnly: true
-        },
-        ...options,
-        ...writeOptions,
-        execute: async function(props, {service}, emit) {
-          const id = generateId(props)
-          let event = {
-            data: props || {},
-            type: genName("Created")
-          }
-          event[idName] = id
-          emit(event)
-          return id
-        }
-      })
-    }
-
-    if(!service.events[genName("Updated")]) { // Events:
-      service.event({
-        name: genName("Updated"),
-        async execute(props) {
-          if(crud.updateMethod == 'create') {
-            await modelRuntime().create({ ...props.data, id: props[idName] })
-          } else {
-            await modelRuntime().update(props[idName], { ...props.data, id: props[idName] })
-          }
-        }
-      })
-    }
-    if(!service.actions[genName("Update")]) {
-      service.action({
-        name: genName("Update"),
-        properties: {
-          ...idProp,
-          ...properties
-        },
-        returns: {
-          type: model,
-          idOnly: true
-        },
-        ...options,
-        ...writeOptions,
-        execute: async function (props, {service}, emit) {
-          let event = {
-            data: {...props},
-            type: genName("Updated")
-          }
-          event[idName] = props[idName]
-          delete event.data[idName]
-          emit(event)
-          return props[idName]
-        }
-      })
-    }
-
-    if(!service.events[genName("Deleted")]) { // Events:
-      service.event({
-        name: genName("Deleted"),
-        async execute(props) {
-          await modelRuntime().delete(props[idName])
-        }
-      })
-    }
-
-    if(!service.actions[genName("Delete")]) {
-      service.action({
-        name: genName("Delete"),
-        properties: idProp,
-        returns: {
-          type: null
-        },
-        ...options,
-        ...writeOptions,
-        execute: async function (props, {service}, emit) {
-          if(crud.deleteTrigger || crud.triggers) {
-            await service.trigger({ type: genName("Deleted") }, { [idName] : props[idName ] })
-          }
-          emit({
-            ...props,
-            type: genName("Deleted")
-          })
-        }
-      })
-    }
-
-    service.view({
-      name: genName("One"),
-      properties: idProp,
-      ...options,
-      ...readOptions,
-      returns: {
-        type: model
-      },
-      daoPath(props) {
-        const id = props[idName]
-        if(!id) throw new Error(idName + " is required")
-        return modelRuntime().path(id)
-      }
-    })
-
-    service.view({
-      name: genName("Range"),
-      properties: {
-        gt: {
-          type: String,
-        },
-        lt: {
-          type: String,
-        },
-        gte: {
-          type: String,
-        },
-        lte: {
-          type: String,
-        },
-        limit: {
-          type: Number
-        },
-        reverse: {
-          type: Boolean
-        }
-      },
-      returns: {
-        type: Array,
-        of: {
-          type: model
-        }
-      },
-      ...options,
-      ...readOptions,
-      daoPath(props) {
-        return modelRuntime().rangePath(props)
-      }
-    })
-  }
-}

package/lib/processors/draftGenerator.js

@@ -1,291 +0,0 @@
-import * as utils from "../utils.js"
-
-function propertyWithoutValidation(property) {
-  let prop = { ...property }
-  delete prop.validation
-  if(prop.draftValidation) prop.validation = prop.draftValidation
-  if(prop.of) prop.of = withoutValidation(prop.of)
-  if(prop.properties) prop.properties = propertiesWithoutValidation(prop)
-  return prop
-}
-
-function propertiesWithoutValidation(properties, validateFields) {
-  let propertiesWV = {}
-  for(let k in properties) {
-    propertiesWV[k] =
-        (validateFields && validateFields.indexOf(k) != -1)
-        ? properties[k]
-        : propertyWithoutValidation(properties[k])
-  }
-  return propertiesWV
-}
-
-export default function(service, app) {
-  if(!service) throw new Error("no service")
-  if(!app) throw new Error("no service")
-  for(let actionName in service.actions) {
-    const action = service.actions[actionName]
-    if (!action.draft) continue
-
-    const actionExecute = action.execute
-    const draft = action.draft
-    const steps = draft.steps
-
-    const modelName = `${actionName}_draft`
-    let indexes = {}
-    let properties = {
-      ...action.properties
-    }
-
-    if(draft.identification) {
-      properties = {
-        ...(draft.identification),
-        ...properties
-      }
-      indexes.identifier = {
-        property: Object.keys(draft.identification)
-      }
-    }
-
-    if(draft.steps) {
-      properties = {
-        draftStep: {
-          type: String
-        },
-        ...properties
-      }
-    }
-
-    const DraftModel = service.model({
-      name: modelName,
-      properties,
-      indexes
-    })
-    function modelRuntime() {
-      return service._runtime.models[modelName]
-    }
-
-    const propertiesWV = propertiesWithoutValidation(properties, draft.validateFields)
-
-    service.action({
-      name: `${actionName}_saveDraft`,
-      properties: {
-        ...propertiesWV,
-        draft: {
-          type: String
-        }
-      },
-      access: draft.saveAccess || draft.access || action.access,
-      async execute(params, {service, client}, emit) {
-        let draft = params.draft
-        if(!draft) draft = app.generateUid()
-        let data = {}
-        for(let k in properties) data[k] = params[k]
-        emit({
-          type: `${actionName}_draftSaved`,
-          draft, data
-        })
-        return draft
-      }
-    })
-    service.event({
-      name: `${actionName}_draftSaved`,
-      async execute(props) {
-        await modelRuntime().create({...props.data, id: props.draft})
-      }
-    })
-
-    service.action({
-      name: `${actionName}_deleteDraft`,
-      properties: {
-        draft: {
-          type: String,
-          validation: ['nonEmpty']
-        }
-      },
-      access: draft.deleteAccess || draft.access || action.access,
-      async execute(params, {service, client}, emit) {
-        emit({
-          type: `${actionName}_draftDeleted`,
-          draft: params.draft
-        })
-      }
-    })
-    service.event({
-      name: `${actionName}_draftDeleted`,
-      async execute({draft}) {
-        await modelRuntime().delete(draft)
-      }
-    })
-
-    service.action({
-      name: `${actionName}_finishDraft`,
-      properties: {
-        ...propertiesWV,
-        draft: {
-          type: String
-        }
-      },
-      access: draft.finishAccess || draft.access || action.access,
-      async execute(params, context, emit) {
-        let draft = params.draft
-        if(!draft) draft = app.generateUid()
-        let actionProps = {}
-        for(let k in action.properties) actionProps[k] = params[k]
-        const result = await actionExecute.call(action, actionProps, context, emit)
-        emit({
-          type: `${actionName}_draftFinished`,
-          draft
-        })
-        return result
-      }
-    })
-    service.event({
-      name: `${actionName}_draftFinished`,
-      async execute({draft}) {
-        await modelRuntime().delete(draft)
-      }
-    })
-
-    service.view({
-      name: `${actionName}_draft`,
-      properties: {
-        draft: {
-          type: String,
-          validation: ['nonEmpty']
-        }
-      },
-      returns: {
-        type: DraftModel
-      },
-      access: draft.readAccess || draft.access || action.access,
-      daoPath({ draft }) {
-        if(!draft) return null
-        return modelRuntime().path(draft)
-      }
-    })
-
-    if(draft.identification) {
-      service.view({
-        name: `${actionName}_drafts`,
-        properties: {
-          ...draft.identification
-        },
-        access: draft.listAccess || draft.access || action.access,
-        daoPath(params) {
-          const ident = Object.keys(draft.identification).map(p => params[p])
-          return modelRuntime().indexRangePath('identifier', ident)
-        }
-      })
-    }
-
-    if(steps) {
-      for(let i = 0; i < steps.length; i++) {
-        const step = steps[i]
-        const nextStep = steps[i + 1]
-
-        //console.log("ACTION PROPERTIES", action.properties)
-        const stepProperties = {}
-        for(let fieldName of step.fields) {
-          utils.setProperty({ properties: stepProperties }, fieldName, utils.getProperty(action, fieldName))
-        }
-        const stepPropertiesVW = propertyWithoutValidation(stepProperties)
-
-        //console.log(`STEP ${step.name} PROPERTIES`, stepProperties)
-        //console.log(`STEP ${step.name} PROPERTIES VW`, stepPropertiesVW)
-
-        service.action({
-          name: `${actionName}_saveStepDraft_${step.name || i}`,
-          properties: stepPropertiesVW,
-          async execute(params, {service, client}, emit) {
-            let draft = params.draft
-            if(!draft) draft = app.generateUid()
-            let data = {}
-            for(let k in properties) data[k] = params[k]
-            emit({
-              type: `${actionName}_stepDraftSaved`,
-              draft, data,
-              draftStep: step.name || i
-            })
-            return draft
-          }
-        })
-        service.event({
-          name: `${actionName}_stepDraftSaved`,
-          async execute(props) {
-            await app.dao.request(['database', 'query', app.databaseName, `(${
-                async (input, output, { table, id, data, draftStep }) => {
-                  const value = await input.table(table).object(id).get()
-                  if(!value) {
-                    return await output.table(table).put({ ...data, id, draftStep })
-                  } else {
-                    return await output.table(table).update(id, [
-                      { op:'merge', property: null, value: { ...data, draftStep} }
-                    ])
-                  }
-                }
-            })`, { table: modelRuntime().tableName, id: props.draft, data: props.data, draftStep: props.draftStep }])
-          }
-        })
-
-        service.action({
-          name: `${actionName}_finishStep_${step.name || i}`,
-          properties: stepProperties,
-          async execute(params, context, emit) {
-            let data = {}
-            console.log("PARAMS", params)
-            for (let k in stepProperties) data[k] = params[k]
-            if(nextStep) {
-              let draft = params.draft
-              if(!draft) draft = app.generateUid()
-              delete data.draftStep
-              emit({
-                type: `${actionName}_stepSaved`,
-                draft, data,
-                draftStep: step.name || i,
-                draftNextStep: nextStep.name || (i + 1)
-              })
-              return draft
-            } else {
-              console.log("PM", params)
-              let actionProps = params.draft ? await modelRuntime().get(params.draft) : {}
-              console.log("AP", actionProps)
-              console.log("DT", data)
-              delete actionProps.draft
-              delete actionProps.draftStep
-              utils.mergeDeep(actionProps, data)
-              const result = await actionExecute.call(action, actionProps, context, emit)
-              if(params.draft) {
-                emit({
-                  type: `${actionName}_draftFinished`,
-                  draft: params.draft
-                })
-              }
-              return result
-            }
-          }
-        })
-        service.event({
-          name: `${actionName}_stepSaved`,
-          async execute(props) {
-            await app.dao.request(['database', 'query', app.databaseName,`(${
-                async (input, output, { table, id, data, draftStep }) => {
-                  const value = await input.table(table).object(id).get()
-                  if(!value) {
-                    return await output.table(table).put({ ...data, id, draftStep })
-                  } else {
-                    return await output.table(table).update(id, [
-                        { op:'merge', property: null, value: { ...data, draftStep} }
-                        ])
-                  }
-                }
-            })`, { table: modelRuntime().tableName, id: props.draft, data: props.data, draftStep: props.draftStep }])
-            //await modelRuntime().create({...props.data, id: props.draft, draftStep: props.draftStep}, { conflict: 'update' })
-          }
-        })
-
-      }
-    }
-
-  }
-}

package/lib/processors/reverseRelation.js

@@ -1,40 +0,0 @@
-import * as utils from "../utils.js"
-
-export default function(module, app) {
-  for(let modelName in module.models) {
-    const model = module.models[modelName]
-    for(let propertyName in model.properties) {
-      const property = model.properties[propertyName]
-      if(property.reverseRelation) { // X to one
-        const reverse = property.reverseRelation
-        const targetModel = module.models[utils.typeName(property.type)]
-        if(reverse.many) {
-          targetModel.createAndAddProperty(reverse.name, {
-            type: "Array",
-            ... reverse.options
-          })
-        } else {
-          targetModel.createAndAddProperty(reverse.name, {
-            type: model,
-            ... reverse.options
-          })
-        }
-      }
-      if(property.of && property.of.reverseRelation) { // X to many
-        const targetModel = module.models[utils.typeName(property.of.type)]
-        const reverse = property.of.reverseRelation
-        if(reverse.many) {
-          targetModel.createAndAddProperty(reverse.name, {
-            type: "Array",
-            ... reverse.options
-          })
-        } else {
-          targetModel.createAndAddProperty(reverse.name, {
-            type: model,
-            ... reverse.options
-          })
-        }
-      }
-    }
-  }
-}

package/lib/runtime/SearchIndexer.js

@@ -1,314 +0,0 @@
-const SEARCH_INDEX_NOTSTARTED = 0
-const SEARCH_INDEX_CREATING = 1
-const SEARCH_INDEX_UPDATING = 2
-const SEARCH_INDEX_READY = 3
-
-const bucketSize = 256
-const saveStateThrottle = 2000
-const saveStateDelay = saveStateThrottle + 200
-
-function prepareArray(data, of) {
-  if(!data) return
-  if(of.properties) for(let i = 0; i < data.length; i++) prepareObject(data[i], of)
-  if(of.of) for(let i = 0; i < data.length; i++) prepareArray(data[i], of.of)
-}
-
-function prepareObject(data, props) {
-  if(!data) return
-  for(const propName in props) {
-    if(!data.hasOwnProperty(propName)) continue
-    const prop = props[propName]
-    if(prop.properties) {
-      prepareObject(data[propName], prop.properties)
-    }
-    if(prop.of) {
-      prepareArray(data[propName], prop.of)
-    }
-    if(prop.search) {
-      if(Array.isArray(prop.search)) {
-        for(const search of prop.search) {
-          if(search.name) data[search.name] = data[propName]
-        }
-      } else {
-        if(prop.search.name) data[prop.search.name] = data[propName]
-      }
-    }
-  }
-}
-
-class SearchIndexer {
-  constructor(dao, databaseName, sourceType, sourceName, elasticsearch, indexName, model ) {
-    this.dao = dao
-    this.databaseName = databaseName
-    this.sourceType = sourceType
-    this.sourceName = sourceName
-    this.elasticsearch = elasticsearch
-    this.indexName = indexName
-    this.model = model
-    this.state = SEARCH_INDEX_NOTSTARTED
-    this.lastUpdateId = ''
-    this.lastSavedId = ''
-
-    this.observable = null
-
-    this.queue = []
-    this.queueWriteResolve = []
-    this.queueLastUpdateId = ''
-    this.queueWritePromise = null
-    this.queueWriteResolve = null
-    this.currentWritePromise = null
-
-    this.readingMore = true
-
-    this.lastStateSave = 0
-    this.saveStateTimer = null
-  }
-
-  prepareObject(object) {
-    prepareObject(object, this.model.properties)
-  }
-
-  async start() {
-    const searchIndexState = await this.dao.get(
-        ['database','tableObject', this.databaseName, 'searchIndexes', this.indexName])
-    const firstSourceOperation = (await this.dao.get(
-        ['database', this.sourceType.toLowerCase()+'OpLogRange', this.databaseName, this.sourceName, {
-          limit: 1
-        }]))[0]
-
-    console.log("Index State", searchIndexState)
-    console.log("first Source Operation", firstSourceOperation && firstSourceOperation.id)
-
-    let lastUpdateTimestamp = 0
-    if(!searchIndexState || (firstSourceOperation && firstSourceOperation.id > searchIndexState.lastOpLogId)) {
-      const indexCreateTimestamp = Date.now()
-      this.state = SEARCH_INDEX_CREATING
-      console.log("CREATING SEARCH INDEX")
-      await this.copyAll()
-      lastUpdateTimestamp = indexCreateTimestamp - 1000 // one second overlay
-      this.lastUpdateId = (''+(lastUpdateTimestamp - 1000)).padStart(16,'0')
-    } else {
-      this.state = SEARCH_INDEX_UPDATING
-      console.log("UPDATING SEARCH INDEX")
-      lastUpdateTimestamp = (+searchIndexState.lastOpLogId.split(':')[0]) - 1000 // one second overlap
-      this.lastUpdateId = searchIndexState.lastOpLogId
-      await this.updateAll()
-    }
-
-    await this.dao.request(['database', 'put', this.databaseName, 'searchIndexes', {
-      id: this.indexName,
-      lastOpLogId: this.lastUpdateId
-    }])
-    this.lastStateSave = Date.now()
-
-    console.log("SEARCH INDEX READY")
-    this.state = SEARCH_INDEX_READY
-
-    this.observeMore()
-  }
-
-  async saveState() {
-    if(this.lastSavedId == this.lastUpdateId) return
-    if(Date.now() - this.lastStateSave < saveStateThrottle) {
-      if(this.saveStateTimer === null) {
-        setTimeout(() => this.saveState(), saveStateDelay)
-      }
-      return
-    }
-    console.log("SAVE INDEXER STATE", this.lastUpdateId)
-    this.lastSavedId = this.lastUpdateId
-    this.lastStateSave = Date.now()
-    await this.dao.request(['database', 'put', this.databaseName, 'searchIndexes', {
-      id: this.indexName,
-      lastOpLogId: this.lastUpdateId
-    }])
-  }
-
-  doWrite() {
-    if(this.queueWritePromise) {
-      return this.queueWritePromise
-    }
-    const operations = this.queue
-    if(operations.length == 0) {
-      this.lastUpdateId = this.queueLastUpdateId
-      return
-    }
-    this.queueWritePromise = new Promise((resolve, reject) => {
-      this.queueWriteResolve = { resolve, reject }
-    })
-    const queueResolve = this.queueWriteResolve
-    this.queueWriteResolve = null
-    this.queueWritePromise = null
-    this.queue = []
-    //console.log("WRITE BULK", operations)
-    this.elasticsearch.bulk({
-      index: this.indexName,
-      body: operations
-    }).catch(error => {
-      error = (error && error.meta && error.meta.body && error.meta.body.error) || error
-      console.error("ES ERROR:", error)
-      queueResolve.reject(error)
-      throw error
-    }).then(result => {
-      //console.log("BULK RESULT", result)
-      if(result.body.errors) {
-        for(const item of result.body.items) {
-          if(item.index.error) {
-            const opId = operations.findIndex(op =>
-                (op.index && op.index._id == item.index._id)
-                || (op.delete && op.delete._id == item.delete._id)
-            )
-            const op = operations[opId]
-            const data = op.index ? operations[opId + 1] : null
-            console.error("INDEX ERROR", item.index.error, "OP", op, "D", data)
-          }
-        }
-        //throw result.body.items.find(item => item.error)
-        throw new Error("INDEXING ERROR "+ result.body.errors)
-      }
-    }).then(written => {
-      this.lastUpdateId = this.queueLastUpdateId
-      queueResolve.resolve()
-      this.currentWritePromise = null
-      this.saveState()
-      if(this.queue.length) {
-        this.doWrite()
-      }
-    })
-    return this.queueWritePromise
-  }
-
-  async applyOps(ops) {
-    //console.trace(`apply ${ops.length} ops`)
-    if(ops.length == 0) return;
-    let size = 0
-    for(const op of ops) {
-      if(op.operation.type == 'put') size += 2
-      if(op.operation.type == 'delete') size += 1
-    }
-    const operations = new Array(size)
-    let pos = 0
-    for(const op of ops) {
-      if(op.operation.type == 'put') {
-        operations[pos++] = { index: { _id: op.operation.object.id } }
-        this.prepareObject(op.operation.object)
-        operations[pos++] = op.operation.object
-      }
-      if(op.operation.type == 'delete') {
-        operations[pos++] = { delete: { _id: op.operation.object.id } }
-      }
-    }
-    const lastUpdateId = ops[ops.length-1].id
-    //console.log("ES OPS", operations)
-    this.queue = this.queue.length ? this.queue.concat(operations) : operations
-    this.queueLastUpdateId = lastUpdateId
-    //console.log("WRITE OPS!")
-    await this.doWrite()
-    //console.log("OPS WRITTEN!")
-  }
-
-  observeMore() {
-    this.readingMore = true
-    if(this.observable) this.observable.unobserve(this)
-    this.observable = this.dao.observable(
-        ['database', this.sourceType.toLowerCase()+'OpLogRange', this.databaseName, this.sourceName, {
-          gt: this.lastUpdateId,
-          limit: bucketSize
-        }])
-    this.observable.observe(this)
-  }
-  tryObserveMore() {
-    if(!this.readingMore && this.observable.list.length == bucketSize) {
-      this.observeMore()
-    }
-  }
-  async set(ops) {
-    this.readingMore = false
-    console.log("SET", this.lastUpdateId, ops.length)
-    await this.applyOps(ops)
-    this.tryObserveMore()
-  }
-  async putByField(_fd, id, op, _reverse, oldObject) {
-    this.readingMore = false
-    await this.applyOps([ op ])
-    this.tryObserveMore()
-  }
-
-  async updateAll() {
-    let ops
-    do {
-      console.log("UPDATE FROM", this.lastUpdateId)
-      ops = await this.dao.get(
-          ['database', this.sourceType.toLowerCase()+'OpLogRange', this.databaseName, this.sourceName, {
-            gt: this.lastUpdateId,
-            limit: bucketSize
-          }])
-      console.log("OPS", ops.length)
-      await this.applyOps(ops)
-      console.log("OPS APPLIED", ops.length)
-    } while(ops.length >= bucketSize)
-  }
-
-  async copyAll() {
-    const search = this.elasticsearch
-    let position = ""
-    let more = true
-
-    console.log("DELETE OLD DATA")
-    await search.delete_by_query({
-      index: this.indexName,
-      body: {
-        query: {
-          match_all: {}
-        }
-      }
-    })
-
-    console.log(`INDEXING ${this.sourceType} ${this.sourceName}`)
-    do {
-      const rows = await this.dao.get(
-          ['database', this.sourceType.toLowerCase()+'Range', this.databaseName, this.sourceName, {
-            gt: position,
-            limit: bucketSize
-          }])
-      position = rows.length ? rows[rows.length-1].id : "\xFF"
-      more = (rows.length == bucketSize)
-
-      if(more) console.log(`READ ${rows.length} ROWS`)
-        else console.log(`READ LAST ${rows.length} ROWS`)
-
-      if(rows.length > 0) {
-        console.log(`WRITING ${rows.length} ROWS`)
-        let operations = new Array(rows.length * 2)
-        for(let i = 0; i < rows.length; i++) {
-          operations[i * 2] = { index: { _id: rows[i].id } }
-          this.prepareObject(rows[i])
-          operations[i * 2 + 1] = rows[i]
-        }
-        await search.bulk({
-          index: this.indexName,
-          body: operations
-        }).then(result => {
-          if(result.body.errors) {
-            for(const item of result.body.items) {
-              if(item.index && item.index.error) {
-                console.error("ES ERROR:", item.index.error)
-                console.error("WHEN INDEXING", rows.find(row => row.id == item.index._id))
-              }
-            }
-            throw new Error("ES ERRORS")
-          }
-        }).catch(error => {
-          error = (error && error.meta && error.meta.body && error.meta.body.error) || error
-          console.error("ES ERROR:", error)
-          throw error
-        })
-      }
-      console.log("ES INDEXED!")
-
-    } while (more)
-  }
-
-}
-
-export default SearchIndexer