@live-change/user-service 0.2.15 → 0.2.20

package/index.js

@@ -5,6 +5,8 @@ const { User, AutheticatedUser } = require('./model.js')
 require('./authenticator.js')
 require('./userProperty.js')
 require('./userItem.js')
+require('./sessionOrUserProperty.js')
+require('./sessionOrUserItem.js')
 
 const Session = definition.foreignModel('session', 'Session')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/user-service",
-  "version": "0.2.15",
+  "version": "0.2.20",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,8 +21,9 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "^0.5.7",
-    "@live-change/relations-plugin": "^0.1.10"
+    "@live-change/framework": "^0.5.10",
+    "@live-change/relations-plugin": "^0.1.10",
+    "pluralize": "8.0.0"
   },
-  "gitHead": "86bc53700aca24da682d1dd414428f03cdc8d2f5"
+  "gitHead": "48b13d32478da797b31f73ed1d6f4271cd68b574"
 }

package/sessionOrUserItem.js

@@ -0,0 +1,192 @@
+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.sessionOrUserItem) {
+      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.sessionOrUserItem
+      const writeableProperties = modelProperties || config.writableProperties
+
+      //console.log("USER ITEM", model)
+
+      model.itemOfAny = {
+        ...config
+      }
+
+      if(config.ownerReadAccess) {
+        const viewName = 'my' + pluralize(modelName)
+        service.views[viewName] = new ViewDefinition({
+          name: viewName,
+          access(params, context) {
+            return config.ownerReadAccess ? config.ownerReadAccess(params, context) : true
+          },
+          properties: App.rangeProperties,
+          daoPath(range, { client, context }) {
+            const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
+            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.userReadAccess ? config.userReadAccess(params, context) : true
+            },
+            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)
+            }
+          })
+        }
+      }
+
+      if(config.ownerCreateAccess || config.ownerWriteAccess) {
+        const eventName = 'ownerOwned' + modelName + 'Created'
+        const actionName = 'createMy' + modelName
+        service.actions[actionName] = new ActionDefinition({
+          name: actionName,
+          access: config.ownerCreateAccess || config.ownerWriteAccess,
+          properties: {
+            ...originalModelProperties,
+            [modelPropertyName]: {
+              type: model,
+              validation: ['localId']
+            }
+          },
+          queuedBy: (command) => command.client.user ? 'u:'+command.client.user : 's:'+command.client.session,
+          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 = client.user ? {
+                  ownerType: 'user_User',
+                  owner: client.user,
+                } : {
+                  ownerType: 'session_Session',
+                  owner: client.session,
+                }
+            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: config.ownerUpdateAccess || config.ownerWriteAccess,
+          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'
+            }
+            if(entity.ownerType == 'session_Session') {
+              if(entity.owner != client.session) 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: config.userDeleteAccess || config.userWriteAccess,
+          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'
+            }
+            if(entity.ownerType == 'session_Session') {
+              if(entity.owner != client.session) 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/sessionOrUserProperty.js

@@ -0,0 +1,177 @@
+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.sessionOrUserProperty) {
+      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.sessionOrUserProperty
+      const writeableProperties = modelProperties || config.writableProperties
+
+      model.propertyOfAny = {
+        ...config
+      }
+
+      if(config.ownerReadAccess) {
+        const viewName = 'my' + modelName
+        service.views[viewName] = new ViewDefinition({
+          name: viewName,
+          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]
+            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 view.access ? view.access(params, context) : true
+            },
+            daoPath(params, { client, context }) {
+              const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
+              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: config.ownerSetAccess || config.ownerWriteAccess,
+          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 = client.user ? {
+              ownerType: 'user_User',
+              owner: client.user,
+            } : {
+              ownerType: 'session_Session',
+              owner: client.session,
+            }
+            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: config.ownerUpdateAccess || config.ownerWriteAccess,
+          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 = client.user ? {
+              ownerType: 'user_User',
+              owner: client.user,
+            } : {
+              ownerType: 'session_Session',
+              owner: client.session,
+            }
+            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: config.ownerResetAccess || config.ownerWriteAccess,
+          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 = client.user ? {
+              ownerType: 'user_User',
+              owner: client.user,
+            } : {
+              ownerType: 'session_Session',
+              owner: client.session,
+            }
+            emit({
+              type: eventName,
+              identifiers
+            })
+          }
+        })
+      }
+
+    }
+  }
+
+})

package/userItem.js

@@ -3,6 +3,8 @@ 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) {
@@ -29,7 +31,7 @@ definition.processor(function(service, app) {
       }
 
       if(config.userReadAccess) {
-        const viewName = 'myUser' + modelName + 's'
+        const viewName = 'myUser' + pluralize(modelName)
         service.views[viewName] = new ViewDefinition({
           name: viewName,
           access(params, context) {
@@ -44,7 +46,7 @@ definition.processor(function(service, app) {
         })
         for(const sortField of config.sortBy || []) {
           const sortFieldUc = sortField.slice(0, 1).toUpperCase() + sortField.slice(1)
-          const viewName = 'myUser' + modelName + 'sBy' + sortFieldUc
+          const viewName = 'myUser' + pluralize(modelName) + 'By' + sortFieldUc
           service.views[viewName] = new ViewDefinition({
             name: viewName,
             access(params, context) {
@@ -72,7 +74,7 @@ definition.processor(function(service, app) {
               validation: ['localId']
             }
           },
-          //queuedBy: (command) => command.client.user,
+          queuedBy: (command) => command.client.user,
           waitForEvents: true,
           async execute(properties, { client, service }, emit) {
             const id = properties[modelPropertyName] || app.generateUid()

package/userProperty.js

@@ -96,7 +96,7 @@ definition.processor(function(service, app) {
 
       if(config.userUpdateAccess || config.userWriteAccess) {
         const eventName = 'userOwned' + modelName + 'Updated'
-        const actionName = 'updateMyuser' + modelName
+        const actionName = 'updateMyUser' + modelName
         service.actions[actionName] = new ActionDefinition({
           name: actionName,
           properties: {
@@ -132,14 +132,14 @@ definition.processor(function(service, app) {
 
       if(config.userResetAccess || config.userWriteAccess) {
         const eventName = 'userOwned' + modelName + 'Reset'
-        const actionName = 'resetMyuser' + modelName
+        const actionName = 'resetMyUser' + modelName
         service.actions[actionName] = new ActionDefinition({
           name: actionName,
           access: config.userResetAccess || config.userWriteAccess,
           queuedBy: (command) => command.client.user,
           waitForEvents: true,
           async execute(properties, {client, service}, emit) {
-            const entity = await modelRuntime().indexObjectGet('byuser', client.user)
+            const entity = await modelRuntime().indexObjectGet('byUser', client.user)
             if (!entity) throw 'not_found'
             emit({
               type: eventName,