@live-change/user-service 0.3.19 → 0.3.21

package/model.js

@@ -85,4 +85,4 @@ definition.event({
   }
 })
 
-module.exports = { User, AuthenticatedUser }
+module.exports = { User, Session, AuthenticatedUser }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/user-service",
-  "version": "0.3.19",
+  "version": "0.3.21",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,9 +21,9 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "0.7.20",
-    "@live-change/relations-plugin": "0.7.20",
+    "@live-change/framework": "0.7.22",
+    "@live-change/relations-plugin": "0.7.22",
     "pluralize": "8.0.0"
   },
-  "gitHead": "5a7c43203f456ef7d9dcd9b34826991f803d5038"
+  "gitHead": "70c50fb3eaafe7d1cf5c07b9916ab5a6bfcc8e34"
 }

package/sessionOrUserItem.js

@@ -1,7 +1,7 @@
 const definition = require("./definition.js")
 const App = require("@live-change/framework")
-const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition } = App
-const { User } = require("./model.js")
+const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition, TriggerDefinition } = App
+const { User, Session } = require("./model.js")
 
 const pluralize = require('pluralize')
 
@@ -35,8 +35,113 @@ definition.processor(function(service, app) {
         to: ['sessionOrUser', ...extendedWith]
       }
 
-      /// TODO: merge on signedIn trigger
-      /// TODO: delete on userDeleted trigger
+      service.trigger({
+        name: 'signedIn',
+        properties: {
+          user: {
+            type: User,
+            validation: ['nonEmpty']
+          },
+          session: {
+            type: Session,
+            validation: ['nonEmpty']
+          },
+        },
+        async execute({ user, session }, { service }, emit) {
+          const sessionPath = ['session_Session', session]
+          const sessionItems = await modelRuntime().indexRangeGet('bySessionOrUser', sessionPath, {} )
+          if(config.merge) {
+            const userPath = ['user_User', user]
+            const userItems = await modelRuntime().indexRangeGet('bySessionOrUser', userPath, {} )
+            const mergeResult = await config.merge(sessionItems, userItems)
+            if(mergeResult) {
+              const { transferred, updated, deleted } = mergeResult
+              for(const entity of transferred) {
+                emit({
+                  type: 'sessionOrUserOwned' + modelName + 'Transferred',
+                  [modelPropertyName]: entity.id,
+                  to: {
+                    sessionOrUserType: 'user_User',
+                    sessionOrUser: user
+                  }
+                })
+              }
+              for(const entity of updated) {
+                emit({
+                  type: 'sessionOrUserOwned' + modelName + 'Updated',
+                  [modelPropertyName]: entity.id,
+                  identifiers: {
+                    id: entity.id,
+                    sessionOrUserType: 'user_User',
+                    sessionOrUser: user
+                  },
+                  data: entity
+                })
+              }
+              for(const entity of deleted) {
+                emit({
+                  type: 'sessionOrUserOwned' + modelName + 'Deleted',
+                  [modelPropertyName]: entity.id,
+                })
+              }
+            }
+          } else {
+            for(const entity of sessionItems) {
+              emit({
+                type: 'sessionOrUserOwned' + modelName + 'Transferred',
+                [modelPropertyName]: entity.id,
+                identifiers: {
+                  id: entity.id
+                },
+                to: {
+                  sessionOrUserType: 'user_User',
+                  sessionOrUser: user
+                }
+              })
+            }
+          }
+        }
+      })
+
+      service.trigger({
+        name: 'userDeleted',
+        properties: {
+          user: {
+            type: User,
+            validation: ['nonEmpty']
+          }
+        },
+        async execute({ user, session }, { service }, emit) {
+          /// TODO: delete on userDeleted trigger
+        }
+      })
+
+      if(config.ownerReadAccess) {
+        const viewName = 'my' + modelName
+        const propertyName = modelName[0].toLowerCase() + modelName.slice(1)
+        service.views[viewName] = new ViewDefinition({
+          name: viewName,
+          access(params, context) {
+            return config.ownerReadAccess ? config.ownerReadAccess(params, context) : true
+          },
+          properties: {
+            [propertyName]: {
+              type: `${service.name}_${modelName}`,
+              validation: ['nonEmpty']
+            }
+          },
+          async daoPath(params, { client, context }) {
+            const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
+            const range = {
+              gte: '_'+ params[propertyName],
+              lte: '_'+ params[propertyName]
+            }
+            const path = modelRuntime().indexObjectPath('bySessionOrUser', owner, range )
+            console.log("DAO PATH", path, "range", range, 'params', params)
+            return path
+          }
+        })
+      }
 
       if(config.ownerReadAccess) {
         const viewName = 'my' + pluralize(modelName)
@@ -49,6 +154,7 @@ definition.processor(function(service, app) {
           daoPath(range, { client, context }) {
             const owner = client.user ? ['user_User', client.user] : ['session_Session', client.session]
             const path = modelRuntime().indexRangePath('bySessionOrUser', owner, range )
+            console.log("DAO PATH", path, "range", range)
             return path
           }
         })
@@ -157,7 +263,7 @@ definition.processor(function(service, app) {
         const validators = App.validation.getValidators(action, service, action)
       }
       if(config.userDeleteAccess || config.userWriteAccess) {
-        const eventName = 'userOwned' + modelName + 'Deleted'
+        const eventName = 'sessionOrUser' + modelName + 'Deleted'
         const actionName = 'deleteMyUser' + modelName
         service.actions[actionName] = new ActionDefinition({
           name: actionName,
@@ -197,4 +303,4 @@ definition.processor(function(service, app) {
     }
   }
 
-})
+})

package/sessionOrUserProperty.js

@@ -1,7 +1,7 @@
 const definition = require("./definition.js")
 const App = require("@live-change/framework")
 const { PropertyDefinition, ViewDefinition, IndexDefinition, ActionDefinition, EventDefinition } = App
-const { User } = require("./model.js")
+const { User, Session } = require("./model.js")
 const { allCombinations } = require("./combinations.js")
 const { createIdentifiersProperties } = require('./utils.js')
 
@@ -39,9 +39,120 @@ definition.processor(function(service, app) {
         to: ['sessionOrUser', ...extendedWith]
       }
 
-      /// TODO: merge on signedIn trigger
-      /// TODO: delete on userDeleted trigger
+      const transferEventName = ['sessionOrUser', ...(extendedWith.map(e => e[0].toUpperCase() + e.slice(1)))]
+        .join('And') + 'Owned' + modelName + 'Transferred'
 
+      service.trigger({
+        name: 'signedIn',
+        properties: {
+          user: {
+            type: User,
+            validation: ['nonEmpty']
+          },
+          session: {
+            type: Session,
+            validation: ['nonEmpty']
+          },
+        },
+        async execute({ user, session }, { service }, emit) {
+          const sessionPath = ['session_Session', session]
+          const sessionPropertyId = sessionPath.map(p => JSON.stringify(p)).join(':')
+          const range = {
+            gte: sessionPropertyId + '', // '' because it can be not-extended
+            lte: sessionPropertyId + ':\xFF'
+          }
+          const sessionProperties = await modelRuntime().rangeGet(range)
+          for(const sessionProperty of sessionProperties) {
+            console.log("SESSION PROPERTY FOUND!", sessionProperty, "MERGE =", config.merge)
+
+            const extendedIdentifiers = {}
+            for(const key of extendedWith) {
+              extendedIdentifiers[key+'Type'] = sessionProperty[key+'Type']
+              extendedIdentifiers[key] = sessionProperty[key]
+            }
+            const userPath = ['user_User', user]
+            for(const key of extendedWith) {
+              userPath.push(extendedIdentifiers[key+'Type'], extendedIdentifiers[key])
+            }
+            const userPropertyId = userPath.map(p => JSON.stringify(p)).join(':')
+            const userProperty = await modelRuntime().get(userPropertyId)
+
+            if(config.merge) {
+              const mergeResult = await config.merge(sessionProperty, userProperty)
+              if(mergeResult && userProperty) {
+                emit({
+                  type: 'sessionOrUserOwned' + modelName + 'Updated',
+                  identifiers: {
+                    sessionOrUserType: 'user_User',
+                    sessionOrUser: user
+                  },
+                  data: mergeResult
+                })
+              } else {
+                emit({
+                  type: 'sessionOrUserOwned' + modelName + 'Set',
+                  identifiers: {
+                    sessionOrUserType: 'user_User',
+                    sessionOrUser: user
+                  },
+                  data: mergeResult
+                })
+              }
+              if(!config.mergeWithoutDelete) {
+                emit({
+                  type: 'sessionOrUserOwned' + modelName + 'Reset',
+                  identifiers: {
+                    sessionOrUserType: 'session_Session',
+                    sessionOrUser: session
+                  }
+                })
+              }
+            } else {
+              if(!userProperty) {
+                await service.trigger({
+                  type: 'contactOrUserOwned' + modelName + 'Moved',
+                  from: {
+                    sessionOrUserType: 'session_Session',
+                    sessionOrUser: session,
+                    ...extendedIdentifiers
+                  },
+                  to: {
+                    sessionOrUserType: 'user_User',
+                    sessionOrUser: user,
+                    ...extendedIdentifiers
+                  },
+                })
+                emit({
+                  type: transferEventName,
+                  from: {
+                    sessionOrUserType: 'session_Session',
+                    sessionOrUser: session,
+                    ...extendedIdentifiers
+                  },
+                  to: {
+                    sessionOrUserType: 'user_User',
+                    sessionOrUser: user,
+                    ...extendedIdentifiers
+                  }
+                })
+              } // else ignore - user property is more important by default
+            }
+          }
+        }
+      })
+
+      service.trigger({
+        name: 'userDeleted',
+        properties: {
+          user: {
+            type: User,
+            validation: ['nonEmpty']
+          }
+        },
+        async execute({ user, session }, { service }, emit) {
+          /// TODO: delete on userDeleted trigger
+        }
+      })
 
       if(config.ownerReadAccess) { // single item view
         const viewName = 'my' + modelName