@live-change/user-service 0.2.25 → 0.2.26

package/combinations.js

@@ -0,0 +1,17 @@
+function combinations(x, n ,p=[]) {
+  if(x.length == 0 || n > x.length) return []
+  if(n == 1 || x.length == 1) return x.map(e=>p.concat([e]))
+  let acc = []
+  for(let i = 0; i < x.length; i++) acc.push(
+      ...combinations(x.slice(i+1), n - 1, p.concat([x[i]]))
+  )
+  return acc
+}
+
+function allCombinations(x) {
+  let acc = []
+  for(let i = 1; i<=x.length; i++) acc.push(...combinations(x,i))
+  return acc
+}
+
+module.exports = { combinations, allCombinations }

package/contactOrUserItem.js

@@ -0,0 +1,266 @@
+const definition = require("./definition.js")
+const App = require("@live-change/framework")
+const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition } = App
+const { User } = require("./model.js")
+
+const pluralize = require('pluralize')
+
+definition.processor(function(service, app) {
+
+  for(let modelName in service.models) {
+    const model = service.models[modelName]
+    if(model.contactOrUserItem) {
+      if(model.properties.owner) throw new Error('user property already exists!!!')
+
+      const originalModelProperties = { ...model.properties }
+      const modelProperties = Object.keys(model.properties)
+      const defaults = App.utils.generateDefault(model.properties)
+      const modelPropertyName = modelName.slice(0, 1).toLowerCase() + modelName.slice(1)
+
+      function modelRuntime() {
+        return service._runtime.models[modelName]
+      }
+
+      const config = model.contactOrUserItem
+      const writeableProperties = modelProperties || config.writableProperties
+
+      //console.log("USER ITEM", model)
+
+      if(model.itemOfAny) throw new Error("model " + modelName + " already have owner")
+      model.itemOfAny = {
+        ...config
+      }
+
+      /*await service.trigger({
+        type: 'contactConnected',
+        contactType: 'email',
+        contact: email,
+        user
+      })*/
+
+      service.trigger({
+        name: 'contactConnected',
+        properties: {
+          contactType: {
+            type: String,
+            validation: ['nonEmpty']
+          },
+          contact: {
+            type: String,
+            validation: ['nonEmpty']
+          },
+          user: {
+            type: User,
+            validation: ['nonEmpty']
+          }
+        },
+        async execute({ contactType, contact, user }, { service }, emit) {
+          const contactPath = [contactType, contact]
+          const contactItems = await modelRuntime().indexRangeGet('byOwner', contactPath, {} )
+          if(config.merge) {
+            const userPath = ['user_User', user]
+            const userItems = await modelRuntime().indexRangeGet('byOwner', userPath, {} )
+            const mergeResult = await config.merge(contactItems, userItems)
+            if(mergeResult) {
+              const { transferred, updated, deleted } = mergeResult
+              for(const entity of transferred) {
+                emit({
+                  type: 'ownerOwned' + modelName + 'Transferred',
+                  [modelPropertyName]: entity.id,
+                  to: {
+                    id: entity.id,
+                    ownerType: 'user_User',
+                    owner: user
+                  }
+                })
+              }
+              for(const entity of updated) {
+                emit({
+                  type: 'ownerOwned' + modelName + 'Updated',
+                  [modelPropertyName]: entity.id,
+                  identifiers: {
+                    id: entity.id,
+                    ownerType: 'user_User',
+                    owner: user
+                  },
+                  data: entity
+                })
+              }
+              for(const entity of deleted) {
+                emit({
+                  type: 'ownerOwned' + modelName + 'Deleted',
+                  [modelPropertyName]: entity.id,
+                })
+              }
+            }
+          } else {
+            for(const entity of contactItems) {
+              emit({
+                type: 'ownerOwned' + modelName + 'Transferred',
+                [modelPropertyName]: entity.id,
+                identifiers: {
+                  id: entity.id,
+                  ownerType: 'user_User',
+                  owner: user
+                }
+              })
+            }
+          }
+        }
+      })
+
+      if(config.ownerReadAccess) {
+        const viewName = 'my' + pluralize(modelName)
+        service.views[viewName] = new ViewDefinition({
+          name: viewName,
+          access(params, context) {
+            return context.client.user && (config.ownerReadAccess ? config.ownerReadAccess(params, context) : true)
+          },
+          properties: App.rangeProperties,
+          daoPath(range, { client, context }) {
+            const owner = ['user_User', client.user]
+            const path = modelRuntime().indexRangePath('byOwner', owner, range )
+            return path
+          }
+        })
+        for(const sortField of config.sortBy || []) {
+          const sortFieldUc = sortField.slice(0, 1).toUpperCase() + sortField.slice(1)
+          const viewName = 'mySessionOrUser' + pluralize(modelName) + 'By' + sortFieldUc
+          service.views[viewName] = new ViewDefinition({
+            name: viewName,
+            access(params, context) {
+              if(!context.client.user) return false
+              return config.ownerReadAccess(params, context)
+            },
+            properties: App.rangeProperties,
+            daoPath(range, { client, context }) {
+              const owner = ['user_User', client.user]
+              return modelRuntime().sortedIndexRangePath('byOwner' + sortFieldUc, owner, range)
+            }
+          })
+        }
+      }
+
+      if(config.ownerCreateAccess || config.ownerWriteAccess) {
+        const eventName = 'ownerOwned' + modelName + 'Created'
+        const actionName = 'createMy' + modelName
+        service.actions[actionName] = new ActionDefinition({
+          name: actionName,
+          access: (params, context) => context.client.user
+              && (config.ownerCreateAccess || config.ownerWriteAccess)(params,context),
+          properties: {
+            ...originalModelProperties,
+            [modelPropertyName]: {
+              type: model,
+              validation: ['localId']
+            }
+          },
+          queuedBy: (command) => 'u:'+command.client.user,
+          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 = {
+              ownerType: 'user_User',
+              owner: client.user,
+            }
+            emit({
+              type: eventName,
+              [modelPropertyName]: id,
+              identifiers,
+              data: properties
+            })
+            return id
+          }
+        })
+      }
+      if(config.ownerUpdateAccess || config.ownerWriteAccess) {
+        const eventName = 'ownerOwned' + modelName + 'Updated'
+        const actionName = 'updateMy' + modelName
+        service.actions[actionName] = new ActionDefinition({
+          name: actionName,
+          access: (params, context) => context.client.user
+              && (config.ownerUpdateAccess || config.ownerWriteAccess)(params,context),
+          properties: {
+            ...originalModelProperties,
+            [modelPropertyName]: {
+              type: model,
+              validation: ['nonEmpty']
+            }
+          },
+          skipValidation: true,
+          queuedBy: (command) => command.client.user ? 'u:'+command.client.user : 's:'+command.client.session,
+          waitForEvents: true,
+          async execute(properties, { client, service }, emit) {
+            const entity = await modelRuntime().get(properties[modelPropertyName])
+            if(!entity) throw 'not_found'
+            if(entity.ownerType == 'user_User') {
+              if(entity.owner != client.user) throw 'not_authorized'
+            } else throw 'not_authorized'
+            let updateObject = {}
+            for(const propertyName of writeableProperties) {
+              if(properties.hasOwnProperty(propertyName)) {
+                updateObject[propertyName] = properties[propertyName]
+              }
+            }
+            const merged = App.utils.mergeDeep({}, entity, updateObject)
+            await App.validation.validate(merged, validators, { source: action, action, service, app, client })
+            const identifiers = client.user ? {
+              ownerType: 'user_User',
+              owner: client.user,
+            } : {
+              ownerType: 'session_Session',
+              owner: client.session,
+            }
+            emit({
+              type: eventName,
+              [modelPropertyName]: entity.id,
+              identifiers,
+              data: properties
+            })
+          }
+        })
+        const action = service.actions[actionName]
+        const validators = App.validation.getValidators(action, service, action)
+      }
+      if(config.userDeleteAccess || config.userWriteAccess) {
+        const eventName = 'userOwned' + modelName + 'Deleted'
+        const actionName = 'deleteMyUser' + modelName
+        service.actions[actionName] = new ActionDefinition({
+          name: actionName,
+          access: (params, context) => context.client.user
+              && (config.ownerDeleteAccess || config.ownerWriteAccess)(params,context),
+          properties: {
+            [modelPropertyName]: {
+              type: model,
+              validation: ['nonEmpty']
+            }
+          },
+          queuedBy: (command) => command.client.user ? 'u:'+command.client.user : 's:'+command.client.session,
+          waitForEvents: true,
+          async execute(properties, { client, service }, emit) {
+            const entity = await modelRuntime().get(properties[modelPropertyName])
+            if(!entity) throw 'not_found'
+            if(entity.ownerType == 'user_User') {
+              if(entity.owner != client.user) throw 'not_authorized'
+            } else throw 'not_authorized'
+            const identifiers = client.user ? {
+              ownerType: 'user_User',
+              owner: client.user,
+            } : {
+              ownerType: 'session_Session',
+              owner: client.session,
+            }
+            emit({
+              type: eventName,
+              [modelPropertyName]: entity.id,
+              identifiers
+            })
+          }
+        })
+      }
+    }
+  }
+
+})

package/contactOrUserProperty.js

@@ -0,0 +1,243 @@
+const definition = require("./definition.js")
+const App = require("@live-change/framework")
+const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition } = App
+const { User } = require("./model.js")
+
+definition.processor(function(service, app) {
+
+  for(let modelName in service.models) {
+    const model = service.models[modelName]
+
+    if(model.contactOrUserProperty) {
+      console.log("MODEL " + modelName + " IS SESSION OR USER PROPERTY, CONFIG:", model.userProperty)
+      if (model.properties.owner) throw new Error('owner property already exists!!!')
+
+      const originalModelProperties = { ...model.properties }
+      const modelProperties = Object.keys(model.properties)
+      const defaults = App.utils.generateDefault(model.properties)
+
+      function modelRuntime() {
+        return service._runtime.models[modelName]
+      }
+
+      const config = model.contactOrUserProperty
+      const writeableProperties = modelProperties || config.writableProperties
+
+      if(model.propertyOfAny) throw new Error("model " + modelName + " already have owner")
+      model.propertyOfAny = {
+        ...config
+      }
+
+      service.trigger({
+        name: 'contactConnected',
+        properties: {
+          contactType: {
+            type: String,
+            validation: ['nonEmpty']
+          },
+          contact: {
+            type: String,
+            validation: ['nonEmpty']
+          },
+          user: {
+            type: User,
+            validation: ['nonEmpty']
+          }
+        },
+        async execute({ contactType, contact, user }, { service }, emit) {
+          const contactPath = [contactType, contact]
+          const contactPropertyId = contactPath.map(p => JSON.stringify(p)).join(':')
+          const contactProperty = await modelRuntime().get(contactPropertyId)
+          if(contactProperty) {
+            const userPath = ['user_User', user]
+            const userPropertyId = userPath.map(p => JSON.stringify(p)).join(':')
+            const userProperty = await modelRuntime().get(userPropertyId)
+            if(config.merge) {
+              const mergeResult = await config.merge(contactProperty, userProperty)
+              if(mergeResult && userProperty) {
+                emit({
+                  type: 'ownerOwned' + modelName + 'Updated',
+                  identifiers: {
+                    ownerType: 'user_User',
+                    owner: user
+                  },
+                  data: mergeResult
+                })
+              } else {
+                emit({
+                  type: 'ownerOwned' + modelName + 'Set',
+                  identifiers: {
+                    ownerType: 'user_User',
+                    owner: user
+                  },
+                  data: mergeResult
+                })
+              }
+              emit({
+                type: 'ownerOwned' + modelName + 'Reset',
+                identifiers: {
+                  ownerType: contactType,
+                  owner: contact
+                }
+              })
+            } else {
+              if(!userProperty) {
+                emit({
+                  type: 'ownerOwned' + modelName + 'Transferred',
+                  from: {
+                    ownerType: contactType,
+                    owner: contact
+                  },
+                  to: {
+                    ownerType: 'user_User',
+                    owner: user
+                  }
+                })
+              }
+            }
+          }
+        }
+      })
+
+      if(config.ownerReadAccess) {
+        const viewName = 'my' + modelName
+        service.views[viewName] = new ViewDefinition({
+          name: viewName,
+          access(params, context) {
+            return context.client.user && (config.ownerReadAccess ? config.ownerReadAccess(params, context) : true)
+          },
+          daoPath(params, { client, context }) {
+            const owner = ['user_User', client.user]
+            const id = owner.map(p => JSON.stringify(p)).join(':')
+            return modelRuntime().path(id)
+          }
+        })
+      }
+
+      if(config.ownerViews) {
+        for(const view of config.userViews) {
+          const viewName = view.name || ('my' + (view.prefix || '') + modelName + (view.suffix || ''))
+          service.views[viewName] = new ViewDefinition({
+            name: viewName,
+            access(params, context) {
+              return context.client.user && (view.access ? view.access(params, context) : true)
+            },
+            daoPath(params, { client, context }) {
+              const owner = ['user_User', client.user]
+              const id = owner.map(p => JSON.stringify(p)).join(':')
+              return view.fields
+                ? modelRuntime().limitedPath(id, view.fields)
+                : modelRuntime().path(id)
+            }
+          })
+        }
+      }
+
+      if(config.ownerSetAccess || config.ownerWriteAccess) {
+        const eventName = 'ownerOwned' + modelName + 'Set'
+        const actionName = 'setMy' + modelName
+        service.actions[actionName] = new ActionDefinition({
+          name: actionName,
+          properties: {
+            ...originalModelProperties
+          },
+          access: (params, context) => context.client.user
+              && (config.ownerSetAccess || config.ownerWriteAccess)(params, context),
+          skipValidation: true,
+          queuedBy: (command) => command.client.user ? 'u:'+command.client.user : 's:'+command.client.session,
+          waitForEvents: true,
+          async execute(properties, {client, service}, emit) {
+            let newObject = {}
+            for(const propertyName of writeableProperties) {
+              if(properties.hasOwnProperty(propertyName)) {
+                newObject[propertyName] = properties[propertyName]
+              }
+            }
+            const data = App.utils.mergeDeep({}, defaults, newObject)
+            await App.validation.validate(data, validators, { source: action, action, service, app, client })
+            const identifiers = {
+              ownerType: 'user_User',
+              owner: client.user,
+            }
+            emit({
+              type: eventName,
+              identifiers,
+              data
+            })
+          }
+        })
+        const action = service.actions[actionName]
+        const validators = App.validation.getValidators(action, service, action)
+      }
+
+      if(config.ownerUpdateAccess || config.ownerWriteAccess) {
+        const eventName = 'ownerOwned' + modelName + 'Updated'
+        const actionName = 'updateMy' + modelName
+        service.actions[actionName] = new ActionDefinition({
+          name: actionName,
+          properties: {
+            ...originalModelProperties
+          },
+          access: (params, context) => context.client.user
+              && (config.ownerUpdateAccess || config.ownerWriteAccess)(params, context),
+          skipValidation: true,
+          queuedBy: (command) => command.client.user ? 'u:'+command.client.user : 's:'+command.client.session,
+          waitForEvents: true,
+          async execute(properties, { client, service }, emit) {
+            const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
+            const id = owner.map(p => JSON.stringify(p)).join(':')
+            const entity = await modelRuntime().get(id)
+            if(!entity) throw 'not_found'
+            let updateObject = {}
+            for(const propertyName of writeableProperties) {
+              if(properties.hasOwnProperty(propertyName)) {
+                updateObject[propertyName] = properties[propertyName]
+              }
+            }
+            const merged = App.utils.mergeDeep({}, entity, updateObject)
+            await App.validation.validate(merged, validators, { source: action, action, service, app, client })
+            const identifiers = {
+              ownerType: 'user_User',
+              owner: client.user,
+            }
+            emit({
+              type: eventName,
+              identifiers,
+              data: properties || {}
+            })
+          }
+        })
+        const action = service.actions[actionName]
+        const validators = App.validation.getValidators(action, service, action)
+      }
+
+      if(config.ownerResetAccess || config.ownerWriteAccess) {
+        const eventName = 'ownerOwned' + modelName + 'Reset'
+        const actionName = 'resetMy' + modelName
+        service.actions[actionName] = new ActionDefinition({
+          name: actionName,
+          access: (params, context) => context.client.user
+              && (config.ownerResetAccess || config.ownerWriteAccess)(params, context),
+          queuedBy: (command) => command.client.user ? 'u:'+command.client.user : 's:'+command.client.session,
+          waitForEvents: true,
+          async execute(properties, {client, service}, emit) {
+            const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
+            const id = owner.map(p => JSON.stringify(p)).join(':')
+            const entity = await modelRuntime().get(id)
+            if (!entity) throw 'not_found'
+            const identifiers = {
+              ownerType: 'user_User',
+              owner: client.user,
+            }
+            emit({
+              type: eventName,
+              identifiers
+            })
+          }
+        })
+      }
+
+    }
+  }
+
+})

package/index.js

@@ -7,6 +7,8 @@ require('./userProperty.js')
 require('./userItem.js')
 require('./sessionOrUserProperty.js')
 require('./sessionOrUserItem.js')
+require('./contactOrUserProperty.js')
+require('./contactOrUserItem.js')
 
 const Session = definition.foreignModel('session', 'Session')
 
@@ -44,6 +46,10 @@ definition.trigger({
   async execute({ user, session }, { client, service }, emit) {
     const userData = await User.get(user)
     if(!userData) throw 'userNotFound'
+    await service.trigger({
+      type: 'signedIn',
+      session, user
+    })
     emit({
       type: "signedIn",
       user, session
@@ -55,6 +61,11 @@ definition.action({
   name: 'signOut',
   async execute({ }, { client, service }, emit) {
     if(!client.user) throw "notSignedIn"
+    await service.trigger({
+      type: 'signedOut',
+      session: client.session,
+      user: client.user
+    })
     emit({
       type: "signedOut",
       user: client.user,
@@ -78,6 +89,10 @@ definition.trigger({
     if(!user) {
       user = app.generateUid()
     }
+    await service.trigger({
+      type: 'signedIn',
+      session, user
+    })
     emit([{
       type: "created",
       user
@@ -98,6 +113,14 @@ definition.action({
   },
   async execute({ }, { client, service }, emit) {
     const user = client.user
+    await service.trigger({
+      type: 'signedOut',
+      session: client.session, user: client.user
+    })
+    await service.trigger({
+      type: 'userDeleted',
+      user: client.user
+    })
     await service.trigger({
       type: 'userDeleted',
       user

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/user-service",
-  "version": "0.2.25",
+  "version": "0.2.26",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,9 +21,9 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "0.5.27",
-    "@live-change/relations-plugin": "^0.5.20",
+    "@live-change/framework": "0.6.0",
+    "@live-change/relations-plugin": "0.6.0",
     "pluralize": "8.0.0"
   },
-  "gitHead": "4ccbe06b5a1ad1c46a907ac079e31a6d72a8591e"
+  "gitHead": "f3d7b9b6c689b9d87df3cb7f64cd75fc72339b7a"
 }

package/sessionOrUserItem.js

@@ -30,6 +30,9 @@ definition.processor(function(service, app) {
         ...config
       }
 
+      /// TODO: merge on signedIn trigger
+      /// TODO: delete on userDeleted trigger
+
       if(config.ownerReadAccess) {
         const viewName = 'my' + pluralize(modelName)
         service.views[viewName] = new ViewDefinition({
@@ -50,13 +53,12 @@ definition.processor(function(service, app) {
           service.views[viewName] = new ViewDefinition({
             name: viewName,
             access(params, context) {
-              if(!context.client.user) return false
-              return config.userReadAccess ? config.userReadAccess(params, context) : true
+              return config.ownerReadAccess(params, context)
             },
             properties: App.rangeProperties,
             daoPath(range, { client, context }) {
               const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
-              return modelRuntime().sortedIndexRangePath('byOwner' + sortFieldUc, owner, range)
+              return modelRuntime().sortedIndexRangePath('byOwner' + sortFieldUc, owner, App.extractRange(range))
             }
           })
         }

package/sessionOrUserProperty.js

@@ -2,6 +2,24 @@ const definition = require("./definition.js")
 const App = require("@live-change/framework")
 const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition } = App
 const { User } = require("./model.js")
+const { allCombinations } = require("./combinations.js")
+
+const pluralize = require('pluralize')
+
+function createIdentifiersProperties(keys) {
+  const identifiers = {}
+  if(keys) for(const key of keys) {
+    identifiers[key] = {
+      type: String,
+      validation: ['nonEmpty']
+    }
+    identifiers[key + 'Type'] = {
+      type: String,
+      validation: ['nonEmpty']
+    }
+  }
+  return identifiers
+}
 
 definition.processor(function(service, app) {
 
@@ -9,8 +27,8 @@ definition.processor(function(service, app) {
     const model = service.models[modelName]
 
     if(model.sessionOrUserProperty) {
-      console.log("MODEL " + modelName + " IS SESSION OR USER PROPERTY, CONFIG:", model.userProperty)
-      if (model.properties.owner) throw new Error('owner property already exists!!!')
+      console.log("MODEL " + modelName + " IS SESSION OR USER PROPERTY, CONFIG:", model.sessionOrUserProperty)
+      if (model.properties.sessionOrUser) throw new Error('sessionOrUser property already exists!!!')
 
       const originalModelProperties = { ...model.properties }
       const modelProperties = Object.keys(model.properties)
@@ -23,26 +41,70 @@ definition.processor(function(service, app) {
       const config = model.sessionOrUserProperty
       const writeableProperties = modelProperties || config.writableProperties
 
+      if(model.propertyOf) throw new Error("model " + modelName + " already have owner")
       if(model.propertyOfAny) throw new Error("model " + modelName + " already have owner")
+
+      const extendedWith = config.extendedWith
+          ? (Array.isArray(config.extendedWith) ? config.extendedWith : [config.extendedWith])
+          : []
       model.propertyOfAny = {
-        ...config
+        ...config,
+        to: ['sessionOrUser', ...extendedWith]
       }
 
-      if(config.ownerReadAccess) {
+      /// TODO: merge on signedIn trigger
+      /// TODO: delete on userDeleted trigger
+
+
+      if(config.ownerReadAccess) { // single item view
         const viewName = 'my' + modelName
+        const identifiers = createIdentifiersProperties(extendedWith)
         service.views[viewName] = new ViewDefinition({
           name: viewName,
+          properties: {
+            ...identifiers
+          },
           access(params, context) {
             return config.ownerReadAccess ? config.ownerReadAccess(params, context) : true
           },
           daoPath(params, { client, context }) {
             const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
+            for(const key of extendedWith) {
+              owner.push(params[key+'Type'], params[key])
+            }
             const id = owner.map(p => JSON.stringify(p)).join(':')
             return modelRuntime().path(id)
           }
         })
       }
 
+      if(config.ownerReadAccess && config.extendedWith) {
+        const extendedCombinations = [[]].concat(allCombinations(extendedWith).slice(0, -1))
+        for(const combination of extendedCombinations) {
+          const propsUpperCase = combination.map(prop => prop[0].toUpperCase() + prop.slice(1))
+          const indexName = 'by' + (combination).map(prop => prop[0].toUpperCase() + prop.slice(1))
+          const viewName = 'my' + propsUpperCase.join('And') + pluralize(modelName)
+          const identifiers = createIdentifiersProperties(combination)
+          service.views[viewName] = new ViewDefinition({
+            name: viewName,
+            properties: {
+              ...identifiers,
+              ...App.rangeProperties,
+            },
+            access(params, context) {
+              return config.ownerReadAccess ? config.ownerReadAccess(params, context) : true
+            },
+            daoPath(params, {client, context}) {
+              const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
+              for (const key of combination) {
+                owner.push(params[key + 'Type'], params[key])
+              }
+              return modelRuntime().indexRangePath(indexName, owner, App.extractRange(params) )
+            }
+          })
+        }
+      }
+
       if(config.ownerViews) {
         for(const view of config.userViews) {
           const viewName = view.name || ('my' + (view.prefix || '') + modelName + (view.suffix || ''))

package/userItem.js

@@ -30,6 +30,8 @@ definition.processor(function(service, app) {
         ...config
       }
 
+      /// TODO: delete on userDeleted trigger
+
       if(config.userReadAccess) {
         const viewName = 'myUser' + pluralize(modelName)
         service.views[viewName] = new ViewDefinition({

package/userProperty.js

@@ -29,6 +29,8 @@ definition.processor(function(service, app) {
         ...config
       }
 
+      /// TODO: delete on userDeleted trigger
+
       if(config.userReadAccess) {
         const viewName = 'myUser' + modelName
         service.views[viewName] = new ViewDefinition({