@live-change/relations-plugin 0.1.8 → 0.1.12

package/index.js

@@ -1,8 +1,10 @@
 const propertyOf = require('./propertyOf.js')
+const itemOf = require('./itemOf.js')
 
 module.exports = function(app, services) {
 
   app.defaultProcessors.push(propertyOf)
+  app.defaultProcessors.push(itemOf)
 }
 
-module.exports.processors = [ propertyOf ]
+module.exports.processors = [ propertyOf, itemOf ]

package/itemOf.js

@@ -0,0 +1,235 @@
+const App = require("@live-change/framework")
+const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition } = App
+
+const {
+  extractIdParts, extractRange, extractIdentifiers, extractObjectData, defineProperties, defineIndex,
+  processModelsAnnotation
+} = require('./utils.js')
+
+function defineView(config, context) {
+  const { service, modelRuntime, otherPropertyNames, joinedOthersPropertyName, joinedOthersClassName,
+    modelName, others, model } = context
+  const indexName = 'by'+context.joinedOthersClassName
+  const viewProperties = {}
+  for (let i = 0; i < others.length; i++) {
+    viewProperties[otherPropertyNames[i]] = new PropertyDefinition({
+      type: others[i],
+      validation: ['nonEmpty']
+    })
+  }
+  const viewName = joinedOthersPropertyName + 'Owned' + modelName + 's'
+  service.views[viewName] = new ViewDefinition({
+    name: viewName,
+    properties: {
+      ...viewProperties,
+      ...App.utils.rangeProperties
+    },
+    returns: {
+      type: Array,
+      of: {
+        type: model
+      }
+    },
+    access: config.readAccess,
+    daoPath(properties, { client, context }) {
+      const idParts = extractIdParts(otherPropertyNames, properties)
+      const range = extractRange(properties)
+      const path = modelRuntime().sortedIndexRangePath(indexName, idParts, range)
+      return path
+    }
+  })
+}
+
+async function defineCreatedEvent(config, context) {
+  const {
+    service, modelRuntime, joinedOthersPropertyName, modelName, modelPropertyName
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Created'
+  service.events[eventName] = new EventDefinition({
+    name: eventName,
+    execute(properties) {
+      const id = properties[modelPropertyName]
+      return modelRuntime().create({ ...properties.data, ...properties.identifiers, id })
+    }
+  })
+}
+
+function defineCreateAction(config, context) {
+  const {
+    service, app, model,  defaults, modelPropertyName, modelRuntime,
+    otherPropertyNames, joinedOthersPropertyName, modelName, writeableProperties, joinedOthersClassName
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Created'
+  const actionName = 'set' + joinedOthersClassName + 'Owned' + modelName
+  service.actions[actionName] = new ActionDefinition({
+    name: actionName,
+    properties: {
+      ...(model.properties)
+    },
+    access: config.createAccess || config.writeAccess,
+    skipValidation: true,
+    //queuedBy: otherPropertyNames,
+    waitForEvents: true,
+    async execute(properties, { client, service }, emit) {
+      const id = properties[modelPropertyName] || app.generateUid()
+      const entity = await modelRuntime().get(id)
+      if(entity) throw 'exists'
+      const identifiers = extractIdentifiers(otherPropertyNames, properties)
+      const data = extractObjectData(writeableProperties, properties, defaults)
+      await App.validation.validate(data, validators, { source: action, action, service, app, client })
+      emit({
+        type: eventName,
+        [modelPropertyName]: id,
+        identifiers, data
+      })
+    }
+  })
+  const action = service.actions[actionName]
+  const validators = App.validation.getValidators(action, service, action)
+}
+
+async function defineUpdatedEvent(config, context) {
+  const {
+    service, modelRuntime, joinedOthersPropertyName, modelName, modelPropertyName
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Updated'
+  service.events[eventName] = new EventDefinition({
+    name: eventName,
+    execute(properties) {
+      const id = properties[modelPropertyName]
+      return modelRuntime().update(id, { ...properties.data, ...properties.identifiers, id })
+    }
+  })
+}
+
+async function defineUpdateAction(config, context) {
+  const {
+    service, app, model, modelRuntime, modelPropertyName,
+    otherPropertyNames, joinedOthersPropertyName, modelName, writeableProperties, joinedOthersClassName
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Updated'
+  const actionName = 'update' + joinedOthersClassName + 'Owned' + modelName
+  service.actions[actionName] = new ActionDefinition({
+    name: actionName,
+    properties: {
+      ...(model.properties)
+    },
+    access: config.updateAccess || config.writeAccess,
+    skipValidation: true,
+    //queuedBy: otherPropertyNames,
+    waitForEvents: true,
+    async execute(properties, {client, service}, emit) {
+      const id = properties[modelPropertyName]
+      const entity = await modelRuntime().get(id)
+      if(!entity) throw 'not_found'
+      const entityIdParts = extractIdParts(otherPropertyNames, entity)
+      const idParts = extractIdParts(otherPropertyNames, properties)
+      if(JSON.stringify(entityIdParts) != JSON.stringify(idParts)) {
+        throw 'not_authorized'
+      }
+      const identifiers = extractIdentifiers(otherPropertyNames, properties)
+      const data = extractObjectData(writeableProperties, properties, entity)
+      await App.validation.validate(data, validators, { source: action, action, service, app, client })
+      emit({
+        type: eventName,
+        [modelPropertyName]: id,
+        identifiers,
+        data
+      })
+    }
+  })
+  const action = service.actions[actionName]
+  const validators = App.validation.getValidators(action, service, action)
+}
+
+async function defineDeletedEvent(config, context) {
+  const {
+    service, modelRuntime, joinedOthersPropertyName, modelName, modelPropertyName
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Deleted'
+  service.events[eventName] = new EventDefinition({
+    name: eventName,
+    execute(properties) {
+      const id = properties[modelPropertyName]
+      return modelRuntime().delete(id)
+    }
+  })
+}
+
+async function defineDeleteAction(config, context) {
+  const {
+    service, app, model, modelRuntime, modelPropertyName,
+    otherPropertyNames, joinedOthersPropertyName, modelName, writeableProperties, joinedOthersClassName
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Deleted'
+  const actionName = 'delete' + joinedOthersClassName + 'Owned' + modelName
+  service.actions[actionName] = new ActionDefinition({
+    name: actionName,
+    properties: {
+      ...(model.properties)
+    },
+    access: config.deleteAccess || config.writeAccess,
+    skipValidation: true,
+    //queuedBy: otherPropertyNames,
+    waitForEvents: true,
+    async execute(properties, {client, service}, emit) {
+      const id = properties[modelPropertyName]
+      const entity = await modelRuntime().get(id)
+      if(!entity) throw new Error('not_found')
+      const entityIdParts = extractIdParts(otherPropertyNames, entity)
+      const idParts = extractIdParts(otherPropertyNames, properties)
+      if(JSON.stringify(entityIdParts) != JSON.stringify(idParts)) {
+        throw new Error('not_authorized')
+      }
+      emit({
+        type: eventName,
+        [modelPropertyName]: id
+      })
+    }
+  })
+}
+
+function defineSortIndex(context, sortFields) {
+  if(!Array.isArray(sortFields)) sortFields = [sortFields]
+  console.log("DEFINE SORT INDEX", sortFields)
+  const sortFieldsUc = sortFields.map(fd=>fd.slice(0, 1).toUpperCase() + fd.slice(1))
+  const indexName = 'by' + context.joinedOthersClassName + sortFieldsUc.join('')
+  context.model.indexes[indexName] = new IndexDefinition({
+    property: [...context.otherPropertyNames, ...sortFields]
+  })
+}
+
+module.exports = function(service, app) {
+  processModelsAnnotation(service, app, 'itemOf', (config, context) => {
+
+    defineProperties(context.model, context.others, context.otherPropertyNames)
+    defineIndex(context.model, context.joinedOthersClassName, context.otherPropertyNames)
+
+    if(config.sortBy) {
+      for(const sortFields of config.sortBy) {
+        defineSortIndex(context, sortFields)
+      }
+    }
+
+    if(config.readAccess) {
+      defineView(config, context)
+    }
+    /// TODO: multiple views with limited fields
+
+    defineCreatedEvent(config, context)
+    defineUpdatedEvent(config, context)
+    defineDeletedEvent(config, context)
+
+    if(config.setAccess || config.writeAccess) {
+      defineCreateAction(config, context)
+    }
+
+    if(config.updateAccess || config.writeAccess) {
+      defineUpdateAction(config, context)
+    }
+
+    if(config.resetAccess || config.writeAccess) {
+      defineDeleteAction(config, context)
+    }
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/relations-plugin",
-  "version": "0.1.8",
+  "version": "0.1.12",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,6 +21,6 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "^0.5.8"
+    "@live-change/framework": "^0.5.14"
   }
 }

package/propertyOf.js

@@ -1,86 +1,63 @@
 const App = require("@live-change/framework")
 const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition } = App
 
+const {
+  extractIdParts, extractIdentifiers, extractObjectData, defineProperties, defineIndex,
+  processModelsAnnotation, generateId
+} = require('./utils.js')
 
-function defineProperties(parents, model, parentPropertyNames) {
-  for (let i = 0; i < parents.length; i++) {
-    model.properties[parentPropertyNames[i]] = new PropertyDefinition({
-      type: parents[i],
-      validation: ['nonEmpty']
-    })
-  }
-}
 
-function defineIndex(model, joinedParentsClassName, parentPropertyNames) {
-  model.indexes['by' + joinedParentsClassName] = new IndexDefinition({
-    property: parentPropertyNames
-  })
-}
-
-function defineView(joinedParentsPropertyName, modelName, service, config, modelRuntime, parents, parentPropertyNames) {
+function defineView(config, context) {
+  const { service, modelRuntime, otherPropertyNames, joinedOthersPropertyName, joinedOthersClassName,
+     modelName, others, model } = context
   const viewProperties = {}
-  for (let i = 0; i < parents.length; i++) {
-    viewProperties[parentPropertyNames[i]] = new PropertyDefinition({
-      type: parents[i],
+  for (let i = 0; i < others.length; i++) {
+    viewProperties[otherPropertyNames[i]] = new PropertyDefinition({
+      type: others[i],
       validation: ['nonEmpty']
     })
   }
-  const viewName = joinedParentsPropertyName + 'Owned' + modelName
+  const viewName = config.name || ((config.prefix ? (prefix + joinedOthersClassName) : joinedOthersPropertyName) +
+    'Owned' + modelName + (config.suffix || ''))
   service.views[viewName] = new ViewDefinition({
     name: viewName,
     properties: {
       ...viewProperties
     },
-    access: config.readAccess,
+    returns: {
+      type: model,
+    },
+    access: config.access,
     daoPath(properties, { client, context }) {
-      const idParts = extractIdParts(parentPropertyNames, properties)
+      const idParts = extractIdParts(otherPropertyNames, properties)
       const id = idParts.length > 1 ? idParts.map(p => JSON.stringify(p)).join(':') : idParts[0]
-      const path = modelRuntime().path(id)
-      console.log("PROPERTY ID", id ,"PATH", path, "OF", properties)
-      //return modelRuntime().indexObjectPath('by' + parents.join('And'), idParts)
+      const path = config.fields ? modelRuntime().limitedPath(id, config.fields) : modelRuntime().path(id)
       return path
     }
   })
 }
 
-function extractIdParts(parentPropertyNames, properties) {
-  const idParts = []
-  for (const propertyName of parentPropertyNames) {
-    idParts.push(properties[propertyName])
-  }
-  return idParts
-}
-
-function extractIdentifiers(parentPropertyNames, properties) {
-  const identifiers = {}
-  const idParts = []
-  for (const propertyName of parentPropertyNames) {
-    identifiers[propertyName] = properties[propertyName]
-    idParts.push(properties[propertyName])
-  }
-  identifiers.id = idParts.length > 1 ? idParts.map(p => JSON.stringify(p)).join(':') : idParts[0]
-  return identifiers
-}
-
-function extractObjectData(writeableProperties, properties, defaults) {
-  let updateObject = {}
-  for (const propertyName of writeableProperties) {
-    if (properties.hasOwnProperty(propertyName)) {
-      newObject[propertyName] = properties[propertyName]
-    }
-  }
-  return App.utils.mergeDeep({}, defaults, updateObject)
-}
-
-async function defineSetAction(joinedParentsPropertyName, modelName, service, parentPropertyNames, modelRuntime, joinedParentsClassName, model, config, writeableProperties, defaults, app) {
-  const eventName = joinedParentsPropertyName + 'Owned' + modelName + 'Set'
+async function defineSetEvent(config, context) {
+  const {
+    service, modelRuntime, joinedOthersPropertyName, modelName, otherPropertyNames
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Set'
   service.events[eventName] = new EventDefinition({
     name: eventName,
     execute(properties) {
-      return modelRuntime().create({ ...properties.data, ...properties.identifiers })
+      const id = generateId(otherPropertyNames, properties.identifiers)
+      return modelRuntime().create({ ...properties.data, ...properties.identifiers, id })
     }
   })
-  const actionName = 'set' + joinedParentsClassName + 'Owned' + modelName
+}
+
+async function defineSetAction(config, context) {
+  const {
+    service, app, model,  defaults,
+    otherPropertyNames, joinedOthersPropertyName, modelName, writeableProperties, joinedOthersClassName
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Set'
+  const actionName = 'set' + joinedOthersClassName + 'Owned' + modelName
   service.actions[actionName] = new ActionDefinition({
     name: actionName,
     properties: {
@@ -88,12 +65,12 @@ async function defineSetAction(joinedParentsPropertyName, modelName, service, pa
     },
     access: config.setAccess || config.writeAccess,
     skipValidation: true,
-    queuedBy: parentPropertyNames,
+    queuedBy: otherPropertyNames,
     waitForEvents: true,
     async execute(properties, {client, service}, emit) {
-      const identifiers = extractIdentifiers(parentPropertyNames, properties)
+      const identifiers = extractIdentifiers(otherPropertyNames, properties)
       const data = extractObjectData(writeableProperties, properties, defaults)
-      await App.validation.validate(data, validators, {source: action, action, service, app, client})
+      await App.validation.validate(data, validators, { source: action, action, service, app, client })
       emit({
         type: eventName,
         identifiers, data
@@ -104,15 +81,27 @@ async function defineSetAction(joinedParentsPropertyName, modelName, service, pa
   const validators = App.validation.getValidators(action, service, action)
 }
 
-async function defineUpdateAction(joinedParentsPropertyName, modelName, service, modelRuntime, joinedParentsClassName, model, config, parentPropertyNames, writeableProperties, app) {
-  const eventName = joinedParentsPropertyName + 'Owned' + modelName + 'Updated'
+async function defineUpdateEvent(config, context) {
+  const {
+    service, modelRuntime, joinedOthersPropertyName, modelName, otherPropertyNames
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Updated'
   service.events[eventName] = new EventDefinition({
     name: eventName,
     execute(properties) {
-      return modelRuntime().update(properties.identifiers.id, {...properties.data, ...properties.identifiers})
+      const id = generateId(otherPropertyNames, properties.identifiers)
+      return modelRuntime().update(id, { ...properties.data, ...properties.identifiers })
     }
   })
-  const actionName = 'update' + joinedParentsClassName + 'Owned' + modelName
+}
+
+async function defineUpdateAction(config, context) {
+  const {
+    service, app, model, modelRuntime,
+    otherPropertyNames, joinedOthersPropertyName, modelName, writeableProperties, joinedOthersClassName
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Updated'
+  const actionName = 'update' + joinedOthersClassName + 'Owned' + modelName
   service.actions[actionName] = new ActionDefinition({
     name: actionName,
     properties: {
@@ -120,14 +109,15 @@ async function defineUpdateAction(joinedParentsPropertyName, modelName, service,
     },
     access: config.updateAccess || config.writeAccess,
     skipValidation: true,
-    queuedBy: parentPropertyNames,
+    queuedBy: otherPropertyNames,
     waitForEvents: true,
     async execute(properties, {client, service}, emit) {
-      const identifiers = extractIdentifiers(parentPropertyNames, properties)
-      const entity = await modelRuntime().get(identifiers.id)
+      const identifiers = extractIdentifiers(otherPropertyNames, properties)
+      const id = generateId(otherPropertyNames, properties)
+      const entity = await modelRuntime().get(id)
       if (!entity) throw new Error('not_found')
       const data = extractObjectData(writeableProperties, properties, entity)
-      await App.validation.validate(data, validators, {source: action, action, service, app, client})
+      await App.validation.validate(data, validators, { source: action, action, service, app, client })
       emit({
         type: eventName,
         identifiers, data
@@ -138,23 +128,42 @@ async function defineUpdateAction(joinedParentsPropertyName, modelName, service,
   const validators = App.validation.getValidators(action, service, action)
 }
 
-async function defineResetAction(joinedParentsPropertyName, modelName, service, modelRuntime, joinedParentsClassName, config, parentPropertyNames) {
-  const eventName = joinedParentsPropertyName + 'Owned' + modelName + 'Reset'
+async function defineResetEvent(config, context) {
+  const {
+    service, modelRuntime, joinedOthersPropertyName, modelName, otherPropertyNames
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Reset'
   service.events[eventName] = new EventDefinition({
     name: eventName,
-    execute({identifiers}) {
-      return modelRuntime().delete(identifiers.id)
+    execute({ identifiers }) {
+      const id = generateId(otherPropertyNames, identifiers)
+      return modelRuntime().delete(id)
     }
   })
-  const actionName = 'reset' + joinedParentsClassName + 'Owned' + modelName
+}
+
+async function defineResetAction(config, context) {
+  const {
+    service, modelRuntime, modelPropertyName,
+    otherPropertyNames, joinedOthersPropertyName, modelName, joinedOthersClassName, model
+  } = context
+  const eventName = joinedOthersPropertyName + 'Owned' + modelName + 'Reset'
+  const actionName = 'reset' + joinedOthersClassName + 'Owned' + modelName
   service.actions[actionName] = new ActionDefinition({
     name: actionName,
+    properties: {
+      [modelPropertyName]: {
+        type: model,
+        validation: ['nonEmpty']
+      }
+    },
     access: config.resetAccess || config.writeAccess,
-    queuedBy: parentPropertyNames,
+    queuedBy: otherPropertyNames,
     waitForEvents: true,
     async execute(properties, {client, service}, emit) {
-      const identifiers = extractIdentifiers(parentPropertyNames, properties)
-      const entity = await modelRuntime().get(identifiers.id)
+      const identifiers = extractIdentifiers(otherPropertyNames, properties)
+      const id = generateId(otherPropertyNames, properties)
+      const entity = await modelRuntime().get(id)
       if (!entity) throw new Error('not_found')
       emit({
         type: eventName,
@@ -164,63 +173,37 @@ async function defineResetAction(joinedParentsPropertyName, modelName, service,
   })
 }
 
-module.exports = function(service, app) {
-  if (!service) throw new Error("no service")
-  if (!app) throw new Error("no app")
-
-  for(let modelName in service.models) {
-    const model = service.models[modelName]
-
-    console.log("PO", modelName, model.propertyOf)
-
-    if(model.propertyOf) {
-      if(model.propertyOfProcessed) throw new Error("duplicated processing of propertyOf processor")
-      model.propertyOfProcessed = true
-      const originalModelProperties = { ...model.properties }
-      const modelProperties = Object.keys(model.properties)
-      const modelPropertyName = modelName.slice(0, 1).toLowerCase() + modelName.slice(1)
-      const defaults = App.utils.generateDefault(originalModelProperties)
-      function modelRuntime() {
-        return service._runtime.models[modelName]
-      }
-      if(!model.indexes) model.indexes = {}
 
-      let config = model.propertyOf // only single ownership is possible, but may be owned by objects set
-      if(typeof config == 'string' || Array.isArray(config)) config = { what: config }
 
-      console.log("MODEL " + modelName + " IS PROPERTY OF " + config.what)
-
-      const parents = (Array.isArray(config.what) ? config.what : [ config.what ])
-          .map(parent => parent.name ? parent.name : parent)
+module.exports = function(service, app) {
+  processModelsAnnotation(service, app, 'propertyOf', (config, context) => {
 
-      const writeableProperties = modelProperties || config.writableProperties
-      console.log("PPP", parents)
-      const parentPropertyNames = parents.map(parent => parent.slice(0, 1).toLowerCase() + parent.slice(1))
-      const joinedParentsPropertyName = parentPropertyNames[0] +
-          (parents.length > 1 ? ('And' + parents.slice(1).join('And')) : '')
-      const joinedParentsClassName = parents.join('And')
+    defineProperties(context.model, context.others, context.otherPropertyNames)
+    defineIndex(context.model, context.joinedOthersClassName, context.otherPropertyNames)
 
-      defineProperties(parents, model, parentPropertyNames)
-      defineIndex(model, joinedParentsClassName, parentPropertyNames)
-      if(config.readAccess) {
-        defineView(joinedParentsPropertyName, modelName, service, config, modelRuntime, parents, parentPropertyNames)
+    if(config.readAccess) {
+      defineView({ ...config, access: config.readAccess }, context)
+    }
+    if(config.views) {
+      for(const view of config.views) {
+        defineView({ ...config, ...view }, context)
       }
-      /// TODO: multiple views with limited fields
+    }
 
-      if(config.setAccess || config.writeAccess) {
-        defineSetAction(joinedParentsPropertyName, modelName, service, parentPropertyNames,
-            modelRuntime, joinedParentsClassName, model, config, writeableProperties, defaults, app)
-      }
+    defineSetEvent(config, context)
+    defineUpdateEvent(config, context)
+    defineResetEvent(config, context)
 
-      if(config.updateAccess || config.writeAccess) {
-        defineUpdateAction(joinedParentsPropertyName, modelName, service, modelRuntime, joinedParentsClassName,
-            model, config, parentPropertyNames, writeableProperties, app)
-      }
+    if(config.setAccess || config.writeAccess) {
+      defineSetAction(config, context)
+    }
 
-      if(config.resetAccess || config.writeAccess) {
-        defineResetAction(joinedParentsPropertyName, modelName, service, modelRuntime, joinedParentsClassName,
-            config, parentPropertyNames);
-      }
+    if(config.updateAccess || config.writeAccess) {
+      defineUpdateAction(config, context)
     }
-  }
+
+    if(config.resetAccess || config.writeAccess) {
+      defineResetAction(config, context);
+    }
+  })
 }

package/utils.js

@@ -0,0 +1,114 @@
+const App = require("@live-change/framework")
+const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition } = App
+
+function extractIdParts(otherPropertyNames, properties) {
+  const idParts = []
+  for (const propertyName of otherPropertyNames) {
+    idParts.push(properties[propertyName])
+  }
+  return idParts
+}
+
+function extractRange(properties) {
+  return {
+    gt: properties.gt,
+    gte: properties.gte,
+    lt: properties.lt,
+    lte: properties.lte,
+    reverse: properties.reverse,
+    limit: properties.limit
+  }
+}
+
+function extractIdentifiers(otherPropertyNames, properties) {
+  const identifiers = {}
+  for (const propertyName of otherPropertyNames) {
+    identifiers[propertyName] = properties[propertyName]
+  }
+  return identifiers
+}
+
+function generateId(otherPropertyNames, properties) {
+  return otherPropertyNames.length > 1
+      ? otherPropertyNames.map(p => JSON.stringify(properties[p])).join(':')
+      : properties[otherPropertyNames[0]]
+}
+
+function extractObjectData(writeableProperties, properties, defaults) {
+  let updateObject = {}
+  for (const propertyName of writeableProperties) {
+    if (properties.hasOwnProperty(propertyName)) {
+      newObject[propertyName] = properties[propertyName]
+    }
+  }
+  return App.utils.mergeDeep({}, defaults, updateObject)
+}
+
+function defineProperties(model, types, names) {
+  for (let i = 0; i < types.length; i++) {
+    model.properties[names[i]] = new PropertyDefinition({
+      type: types[i],
+      validation: ['nonEmpty']
+    })
+  }
+}
+
+function defineIndex(model, what, props) {
+  model.indexes['by' + what] = new IndexDefinition({
+    property: props
+  })
+}
+
+function processModelsAnnotation(service, app, annotation, cb) {
+  if (!service) throw new Error("no service")
+  if (!app) throw new Error("no app")
+
+  for(let modelName in service.models) {
+    const model = service.models[modelName]
+
+    //console.log("PO", modelName, model[annotation])
+
+    if (model[annotation]) {
+      if (model[annotation + 'Processed']) throw new Error("duplicated processing of " + annotation + " processor")
+      model[annotation + 'Processed'] = true
+      const originalModelProperties = { ...model.properties }
+      const modelProperties = Object.keys(model.properties)
+      const modelPropertyName = modelName.slice(0, 1).toLowerCase() + modelName.slice(1)
+      const defaults = App.utils.generateDefault(originalModelProperties)
+
+      function modelRuntime() {
+        return service._runtime.models[modelName]
+      }
+
+      if (!model.indexes) model.indexes = {}
+
+      let config = model[annotation] // only single ownership is possible, but may be owned by objects set
+      if (typeof config == 'string' || Array.isArray(config)) config = {what: config}
+
+      console.log("MODEL " + modelName + " IS "+ annotation +" " + config.what)
+
+      const others = (Array.isArray(config.what) ? config.what : [config.what])
+          .map(other => other.name ? other.name : other)
+
+      const writeableProperties = modelProperties || config.writeableProperties
+      console.log("PPP", others)
+      const otherPropertyNames = others.map(other => other.slice(0, 1).toLowerCase() + other.slice(1))
+      const joinedOthersPropertyName = otherPropertyNames[0] +
+          (others.length > 1 ? ('And' + others.slice(1).join('And')) : '')
+      const joinedOthersClassName = others.join('And')
+
+      const context = {
+        service, app, model, originalModelProperties, modelProperties, modelPropertyName, defaults, modelRuntime,
+        otherPropertyNames, joinedOthersPropertyName, modelName, writeableProperties, joinedOthersClassName,
+        others
+      }
+
+      cb(config, context)
+    }
+  }
+}
+
+module.exports = {
+  extractIdParts, extractIdentifiers, extractObjectData, defineProperties, defineIndex,
+  processModelsAnnotation, extractRange, generateId
+}