@live-change/session-service 0.1.7 → 0.1.12

package/authenticator.js

@@ -3,30 +3,33 @@ const app = App.app()
 const definition = require('./definition.js')
 const Session = require('./model.js')
 const { createHmac } = require('crypto')
+const config = definition.config
 
-definition.authenticator(async function(credentials, config) {
-  const sessionKey = credentials.sessionKey
-  if(!sessionKey) throw new Error("sessionKey required!")
-  const sessions = await app.dao.get(
-      ['database', 'indexRange', app.databaseName, Session.tableName + '_byKey', {
-        gt: `"${sessionKey}"_`,
-        lt: `"${sessionKey}"_\xFF`
-      }])
-  //console.log("FOUND SESSIONS", sessions)
-  let session = sessions[0]?.to
-  if(!session) {
-    if(config.createSessionOnUpdate) {
-      session = createHmac('sha256', config.sessionHmacSecret || 'secret')
-          .update(credentials.sessionKey)
-          .digest('base64').slice(0, 32)
-    } else {
-      const createResult = await app.triggerService(definition.name, {
-        type: "createSessionKeyIfNotExists",
-        sessionKey
-      })
-      //console.log("CREATE SESSION RESULT", createResult)
-      session = createResult.session
+definition.authenticator({
+  async prepareCredentials(credentials) {
+    const sessionKey = credentials.sessionKey
+    if(!sessionKey) throw new Error("sessionKey required!")
+    const sessions = await app.dao.get(
+        ['database', 'indexRange', app.databaseName, Session.tableName + '_byKey', {
+          gt: `"${sessionKey}"_`,
+          lt: `"${sessionKey}"_\xFF`
+        }])
+    //console.log("FOUND SESSIONS", sessions)
+    let session = sessions[0]?.to
+    if(!session) {
+      if(config.createSessionOnUpdate) {
+        session = createHmac('sha256', config.sessionHmacSecret || 'secret')
+            .update(credentials.sessionKey)
+            .digest('base64').slice(0, 32)
+      } else {
+        const createResult = await app.triggerService(definition.name, {
+          type: "createSessionKeyIfNotExists",
+          sessionKey
+        })
+        //console.log("CREATE SESSION RESULT", createResult)
+        session = createResult.session
+      }
     }
+    credentials.session = session
   }
-  credentials.session = session
 })

package/definition.js

@@ -1,8 +1,11 @@
 const App = require("@live-change/framework")
 const app = App.app()
 
+const relationsPlugin = require('@live-change/relations-plugin')
+
 const definition = app.createServiceDefinition({
-  name: "session"
+  name: "session",
+  use: [ relationsPlugin ]
 })
 
 module.exports = definition

package/index.js

@@ -3,10 +3,6 @@ const app = App.app()
 const definition = require('./definition.js')
 const Session = require('./model.js')
 
-
-const User = definition.foreignModel('user', 'User')
-
-
 definition.view({
   name: 'currentSession',
   properties: {},
@@ -20,7 +16,6 @@ definition.view({
       async (input, output, { session, tableName }) => {
         const mapper = (obj) => (obj || {
           id: session,
-          user: null,
           roles: []
         })
         let storedObj = undefined
@@ -81,50 +76,9 @@ definition.trigger({
   }
 })
 
-definition.action({
-  name: "logout",
-  properties: {
-  },
-  async execute({ session }, { client, service }, emit) {
-    if(!session) session = client.session
-    if(session != client.session) throw new Error("Wrong session id")
-    const sessionRow = await Session.get(session)
-    if(!sessionRow) throw 'notFound'
-    if(!sessionRow.user) throw "loggedOut"
-    emit({
-      type: "loggedOut",
-      session
-    })
-    await service.trigger({
-      type: "OnLogout",
-      user: sessionRow.user,
-      session: client.session
-    })
-    return 'loggedOut'
-  }
-})
-
-definition.trigger({
-  name: "UserDeleted",
-  properties: {
-    user: {
-      type: User,
-      idOnly: true
-    }
-  },
-  async execute({ user }, context, emit) {
-    emit([{
-      type: "UserDeleted",
-      user
-    }])
-  }
-})
-
-
 require('./authenticator.js')
 require('./localIdValidator.js')
 require('./sessionProperty.js')
 require('./sessionItem.js')
 
-
 module.exports = definition

package/model.js

@@ -1,29 +1,15 @@
 const definition = require("./definition.js")
 
-const User = definition.foreignModel('user', 'User')
-
 const Session = definition.model({
   name: "Session",
   properties: {
     key: {
       type: String
-    },
-    user: {
-      type: User
-    },
-    roles: {
-      type: Array,
-      of: {
-        type: String
-      }
     }
   },
   indexes: {
     byKey: {
       property: 'key'
-    },
-    byUser: {
-      property: "user"
     }
   }
 })
@@ -39,114 +25,10 @@ definition.event({
     }
   },
   async execute({ session, key }) {
-    console.log("SESSION CREATING!", session, "AT", (new Date()).toISOString())
     await Session.create({
       id: session,
-      key: key,
-      user: null,
-      roles: []
+      key: key
     })
-    console.log("SESSION CREATED!", session, "AT", (new Date()).toISOString())
-  }
-})
-
-definition.event({
-  name: "loggedIn",
-  properties: {
-    session: {
-      type: Session
-    },
-    user: {
-      type: User
-    },
-    roles: {
-      type: Array,
-      of: {
-        type: String
-      }
-    },
-    expire: {
-      type: Date
-    }
-  },
-  async execute({ session, user, roles, expire, language, timezone }) {
-    console.log("SESSION UPDATE", session, { user, roles, expire, language, timezone })
-    await Session.update(session, { user, roles, expire, language, timezone })
-  }
-})
-
-definition.event({
-  name: "loggedOut",
-  properties: {
-    session: {
-      type: Session
-    }
-  },
-  async execute({ session }) {
-    await Session.update(session, [
-      { op: 'reverseMerge', value: { id: session } },
-      { op: 'merge', value: { user: null, roles: [] } }
-    ])
-  }
-})
-
-definition.event({
-  name: "UserDeleted",
-  properties: {
-    user: {
-      type: User
-    }
-  },
-  async execute({ user }) {
-    await app.dao.request(['database', 'query'], app.databaseName, `(${
-        async (input, output, { table, index, user }) => {
-          const prefix = `"${user}"_`
-          await (await input.index(index)).range({
-            gte: prefix,
-            lte: prefix+"\xFF\xFF\xFF\xFF"
-          }).onChange((ind, oldInd) => {
-            if(ind && ind.to) {
-              output.table(table).update(ind.to, [
-                { op: 'reverseMerge', value: { id: ind.to } },
-                { op: 'merge', value: { user: null, roles: [], expire: null } }
-              ])
-            }
-          })
-        }
-    })`, { table: Session.tableName, index: Session.tableName + '_byUser', user })
-  }
-})
-
-definition.event({
-  name: "rolesUpdated",
-  properties: {
-    user: {
-      type: User
-    },
-    roles: {
-      type: Array,
-      of: {
-        type: String
-      }
-    }
-  },
-  async execute({ user, roles }) {
-    await app.dao.request(['database', 'query'], app.databaseName, `(${
-        async (input, output, { table, index, user, roles }) => {
-          const prefix = `"${user}"_`
-          await (await input.index(index)).range({
-            gte: prefix,
-            lte: prefix+"\xFF\xFF\xFF\xFF"
-          }).onChange((ind, oldInd) => {
-            if(ind && ind.to) {
-              output.table(table).update(ind.to, [
-                { op: 'reverseMerge', value: { id: session } },
-                { op: 'merge', value: { roles } }
-              ])
-            }
-          })
-        }
-    })`, { table: Session.tableName, index: Session.tableName + '_byUser', user, roles })
   }
 })
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/session-service",
-  "version": "0.1.7",
+  "version": "0.1.12",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,6 +21,7 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "^0.5.7"
+    "@live-change/framework": "^0.5.7",
+    "@live-change/relations-plugin": "^0.1.10"
   }
 }

package/sessionItem.js

@@ -12,7 +12,7 @@ definition.processor(function(service, app) {
       if (model.properties.session) throw new Error('session property already exists!!!')
       const originalModelProperties = {...model.properties}
       const modelProperties = Object.keys(model.properties)
-      const defaults = App.utils.generateDefault(modelProperties)
+      const defaults = App.utils.generateDefault(model.properties)
       const modelPropertyName = modelName.slice(0, 1).toLowerCase() + modelName.slice(1)
 
       function modelRuntime() {
@@ -22,28 +22,18 @@ definition.processor(function(service, app) {
       const config = model.sessionItem
       const writeableProperties = modelProperties || config.writableProperties
 
-      console.log("SESSIONM ITEM", model)
+      console.log("SESSION ITEM", model)
 
-      model.properties.session = new PropertyDefinition({
-        type: Session,
-        validation: ['nonEmpty']
-      })
-      if(!model.indexes) model.indexes = {}
-      model.indexes.bySession = new IndexDefinition({
-        property: 'session'
-      })
-      for(const sortField of config.sortBy) {
-        const sortFieldUc = sortField.slice(0, 1).toUpperCase() + sortField.slice(1)
-        model.indexes['bySession' + sortFieldUc] = new IndexDefinition({
-          property: ['session', sortField]
-        })
+      model.itemOf = {
+        what: Session,
+        ...config
       }
 
-      if(config.readAccess) {
-        const viewName = 'session' + modelName + 's'
+      if(config.sessionReadAccess) {
+        const viewName = 'mySession' + modelName + 's'
         service.views[viewName] = new ViewDefinition({
           name: viewName,
-          access: config.readAccess,
+          access: config.sessionReadAccess,
           properties: App.rangeProperties,
           daoPath(range, { client, context }) {
             const path = modelRuntime().indexRangePath('bySession', [client.session], range )
@@ -52,7 +42,7 @@ definition.processor(function(service, app) {
         })
         for(const sortField of config.sortBy) {
           const sortFieldUc = sortField.slice(0, 1).toUpperCase() + sortField.slice(1)
-          const viewName = 'session' + modelName + 'sBy' + sortFieldUc
+          const viewName = 'mySession' + modelName + 'sBy' + sortFieldUc
           service.views[viewName] = new ViewDefinition({
             name: viewName,
             access: config.readAccess,
@@ -63,45 +53,13 @@ definition.processor(function(service, app) {
           })
         }
       }
-      if(config.publicAccess) {
-        const viewName = 'publicSession' + modelName + 's'
-        service.views[viewName] = new ViewDefinition({
-          name: viewName,
-          access: config.publicAccess,
-          properties: App.rangeProperties,
-          daoPath(range, { client, context }) {
-            return modelRuntime().sortedIndexRangePath('bySession', [range.session], { ...range, session: undefined } )
-          }
-        })
-        for(const sorfField of config.sortBy) {
-          const sortFieldUc = sorfField.slice(0, 1).toUpperCase() + sortField.slice(1)
-          const viewName = 'publicSession' + modelName + 'sBy' + sortFieldUc
-          service.views[viewName] = new ViewDefinition({
-            name: viewName,
-            access: config.publicAccess,
-            properties: App.rangeProperties,
-            daoPath(range, { client, context }) {
-              return modelRuntime().sortedIndexRangePath('bySession' + sortFieldUc, [client.session], range )
-            }
-          })
-        }
-      }
 
-      if(config.createAccess || config.writeAccess) {
-        const eventName = 'session' + modelName + 'Created'
-        service.events[eventName] = new EventDefinition({
-          name: eventName,
-          execute(properties) {
-            const data = properties.data
-            const session = properties.session
-            const id = properties[modelPropertyName]
-            return modelRuntime().create({ ...data, session, id })
-          }
-        })
-        const actionName = 'createSession' + modelName
+      if(config.sessionCreateAccess || config.sessionWriteAccess) {
+        const eventName = 'sessionOwned' + modelName + 'Created'
+        const actionName = 'createMySession' + modelName
         service.actions[actionName] = new ActionDefinition({
           name: actionName,
-          access: config.createAccess || config.writeAccess,
+          access: config.sessionCreateAccess || config.sessionWriteAccess,
           properties: {
             ...originalModelProperties,
             [modelPropertyName]: {
@@ -109,35 +67,30 @@ definition.processor(function(service, app) {
               validation: ['localId']
             }
           },
-          queuedBy: (command) => command.client.session,
+          //queuedBy: (command) => 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'
             emit({
               type: eventName,
               [modelPropertyName]: id,
-              session: client.session,
+              identifiers: {
+                session: client.session,
+              },
               data: properties
             })
             return id
           }
         })
       }
-      if(config.updateAccess || config.writeAccess) {
-        const eventName = 'session' + modelName + 'Updated'
-        service.events[eventName] = new EventDefinition({
-          name: eventName,
-          execute(properties) {
-            const data = properties.data
-            const id = properties[modelPropertyName]
-            const session = properties.session
-            return modelRuntime().update(id, { ...data, id, session })
-          }
-        })
-        const actionName = 'updateSession' + modelName
+      if(config.sessionUpdateAccess || config.sessionWriteAccess) {
+        const eventName = 'sessionOwned' + modelName + 'Updated'
+        const actionName = 'updateMySession' + modelName
         service.actions[actionName] = new ActionDefinition({
           name: actionName,
-          access: config.updateAccess || config.writeAccess,
+          access: config.sessionUpdateAccess || config.sessionWriteAccess,
           properties: {
             ...originalModelProperties,
             [modelPropertyName]: {
@@ -150,8 +103,8 @@ definition.processor(function(service, app) {
           waitForEvents: true,
           async execute(properties, { client, service }, emit) {
             const entity = await modelRuntime().get(properties[modelPropertyName])
-            if(!entity) throw new Error('not_found')
-            if(entity.session != client.session) throw new Error('not_authorized')
+            if(!entity) throw 'not_found'
+            if(entity.session != client.session) throw 'not_authorized'
             let updateObject = {}
             for(const propertyName of writeableProperties) {
               if(properties.hasOwnProperty(propertyName)) {
@@ -159,12 +112,13 @@ definition.processor(function(service, app) {
               }
             }
             const merged = App.utils.mergeDeep({}, entity, updateObject)
-            console.log("VALIDATE INTERNAL!!!!", merged)
             await App.validation.validate(merged, validators, { source: action, action, service, app, client })
             emit({
               type: eventName,
               [modelPropertyName]: entity.id,
-              session: client.session,
+              identifiers: {
+                session: client.session,
+              },
               data: properties
             })
           }
@@ -172,19 +126,12 @@ definition.processor(function(service, app) {
         const action = service.actions[actionName]
         const validators = App.validation.getValidators(action, service, action)
       }
-      if(config.deleteAccess || config.writeAccess) {
-        const eventName = 'session' + modelName + 'Deleted'
-        service.events[eventName] = new EventDefinition({
-          name: eventName,
-          execute(properties) {
-            const id = properties[modelPropertyName]
-            return modelRuntime().delete(id)
-          }
-        })
-        const actionName = 'deleteSession' + modelName
+      if(config.sessionDeleteAccess || config.sessionWriteAccess) {
+        const eventName = 'sessionOwned' + modelName + 'Deleted'
+        const actionName = 'deleteMySession' + modelName
         service.actions[actionName] = new ActionDefinition({
           name: actionName,
-          access: config.createAccess || config.writeAccess,
+          access: config.sessionDeleteAccess || config.sessionWriteAccess,
           properties: {
             [modelPropertyName]: {
               type: model,
@@ -195,12 +142,14 @@ definition.processor(function(service, app) {
           waitForEvents: true,
           async execute(properties, { client, service }, emit) {
             const entity = await modelRuntime().get(properties[modelPropertyName])
-            if(!entity) throw new Error('not_found')
-            if(entity.session != client.session) throw new Error('not_authorized')
+            if(!entity) throw 'not_found'
+            if(entity.session != client.session) throw 'not_authorized'
             emit({
               type: eventName,
-              session: client.session,
-              [modelPropertyName]: entity.id
+              [modelPropertyName]: entity.id,
+              identifiers: {
+                session: client.session
+              }
             })
           }
         })

package/sessionProperty.js

@@ -7,20 +7,28 @@ definition.processor(function(service, app) {
 
   for(let modelName in service.models) {
     const model = service.models[modelName]
+    console.log("SP", modelName)
 
     if(model.sessionProperty) {
-      console.trace("PROCESS MODEL " + modelName)
+      console.log("MODEL " + modelName + " IS SESSION PROPERTY, CONFIG:", model.sessionProperty)
       if (model.properties.session) throw new Error('session property already exists!!!')
+
       const originalModelProperties = {...model.properties}
       const modelProperties = Object.keys(model.properties)
-      const defaults = App.utils.generateDefault(modelProperties)
-      const modelPropertyName = modelName.slice(0, 1).toLowerCase() + modelName.slice(1)
+      const defaults = App.utils.generateDefault(model.properties)
 
       function modelRuntime() {
         return service._runtime.models[modelName]
       }
 
       const config = model.sessionProperty
+      const writeableProperties = modelProperties || config.writableProperties
+
+      model.propertyOf = {
+        what: Session,
+        ...config
+      }
+
       model.properties.session = new PropertyDefinition({
         type: Session,
         validation: ['nonEmpty']
@@ -29,78 +37,67 @@ definition.processor(function(service, app) {
       model.indexes.bySession = new IndexDefinition({
         property: 'session'
       })
-      if(config.readAccess) {
-        const viewName = 'session' + modelName
-        service.views[viewName] = new ViewDefinition({
-          name: viewName,
-          access: config.readAccess,
-          daoPath(params, {client, context}) {
-            return modelRuntime().indexObjectPath('bySession', client.session)
-          }
-        })
-      }
-      if(config.publicAccess) {
-        const viewName = 'publicSession' + modelName
+      if(config.sessionReadAccess) {
+        const viewName = 'mySession' + modelName
         service.views[viewName] = new ViewDefinition({
           name: viewName,
-          access: config.publicAccess,
-          daoPath({session}, {client, context}) {
-            return modelRuntime().indexObjectPath('bySession', session)
+          access: config.sessionReadAccess,
+          daoPath(params, { client, context }) {
+            return modelRuntime().path(client.session)
+            //return modelRuntime().indexObjectPath('bySession', client.session)
           }
         })
       }
 
-      if(config.setAccess || config.writeAccess) {
-        const eventName = 'session' + modelName + 'Set'
-        service.events[eventName] = new EventDefinition({
-          name: eventName,
+      if(config.sessionSetAccess || config.sessionWriteAccess) {
+        const eventName = 'sessionOwned' + modelName + 'Set'
+        const actionName = 'setMySession' + modelName
+        service.actions[actionName] = new ActionDefinition({
+          name: actionName,
           properties: {
             ...originalModelProperties
           },
-          execute(properties) {
-            const data = properties.data
-            const session = properties.session
-            return modelRuntime().create({...data, session, id: session})
-          }
-        })
-        const actionName = 'setSession' + modelName
-        service.actions[actionName] = new ActionDefinition({
-          name: actionName,
-          access: config.createAccess || config.writeAccess,
+          access: config.sessionSetAccess || config.sessionWriteAccess,
+          skipValidation: true,
           queuedBy: (command) => 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 })
             emit({
               type: eventName,
-              session: client.session,
-              data: properties || {}
+              identifiers: {
+                session: client.session
+              },
+              data
             })
           }
         })
+        const action = service.actions[actionName]
+        const validators = App.validation.getValidators(action, service, action)
       }
-      if(config.updateAccess || config.writeAccess) {
-        const eventName = 'session' + modelName + 'Updated'
-        service.events[eventName] = new EventDefinition({
-          name: eventName,
-          execute(properties) {
-            const data = properties.data
-            const session = properties.session
-            return modelRuntime().update(session, { ...data, session, id: session })
-          }
-        })
-        const actionName = 'updateSession' + modelName
+
+      if(config.sessionUpdateAccess || config.sessionWriteAccess) {
+        const eventName = 'sessionOwned' + modelName + 'Updated'
+        const actionName = 'updateMySession' + modelName
         service.actions[actionName] = new ActionDefinition({
           name: actionName,
           properties: {
             ...originalModelProperties
           },
-          access: config.updateAccess || config.writeAccess,
+          access: config.sessionUpdateAccess || config.sessionWriteAccess,
           skipValidation: true,
           queuedBy: (command) => command.client.session,
           waitForEvents: true,
           async execute(properties, { client, service }, emit) {
             const entity = await modelRuntime().get(client.session)
-            if(!entity) throw new Error('not_found')
+            if(!entity) throw 'not_found'
             let updateObject = {}
             for(const propertyName of writeableProperties) {
               if(properties.hasOwnProperty(propertyName)) {
@@ -111,7 +108,9 @@ definition.processor(function(service, app) {
             await App.validation.validate(merged, validators, { source: action, action, service, app, client })
             emit({
               type: eventName,
-              session: client.session,
+              identifiers: {
+                session: client.session
+              },
               data: properties || {}
             })
           }
@@ -119,30 +118,28 @@ definition.processor(function(service, app) {
         const action = service.actions[actionName]
         const validators = App.validation.getValidators(action, service, action)
       }
-      if(config.resetAccess || config.writeAccess) {
-        const eventName = 'session' + modelName + 'Reset'
-        service.events[eventName] = new EventDefinition({
-          name: eventName,
-          execute({session}) {
-            return modelRuntime().delete(session)
-          }
-        })
-        const actionName = 'resetSession' + modelName
+
+      if(config.sessionResetAccess || config.sessionWriteAccess) {
+        const eventName = 'sessionOwned' + modelName + 'Reset'
+        const actionName = 'resetMySession' + modelName
         service.actions[actionName] = new ActionDefinition({
           name: actionName,
-          access: config.createAccess || config.writeAccess,
+          access: config.sessionResetAccess || config.sessionWriteAccess,
           queuedBy: (command) => command.client.session,
           waitForEvents: true,
           async execute(properties, {client, service}, emit) {
             const entity = await modelRuntime().indexObjectGet('bySession', client.session)
-            if (!entity) throw new Error('not_found')
+            if (!entity) throw 'not_found'
             emit({
               type: eventName,
-              session: client.session,
+              identifiers: {
+                session: client.session
+              }
             })
           }
         })
       }
+
     }
   }