@live-change/prosemirror-service 0.2.51 → 0.3.0

package/index.js

@@ -3,19 +3,38 @@ const app = App.app()
 
 const definition = require('./definition.js')
 const config = definition.config
+const {
+  readerRoles = ['writer'],
+  writerRoles = ['writer'],
+  testLatency
+} = config
 
-const { Document, StepsBucket, schemas, getDocument } = require("./model.js")
+const writerAccessControl = {
+  roles: writerRoles,
+  objects: p => [{ objectType: p.targetType, object: p.target }]
+}
+
+const readerAccessControl = {
+  roles: readerRoles,
+  objects: p => [{ objectType: p.targetType, object: p.target }]
+}
+
+const { Document, StepsBucket, Snapshot, schemas, getDocument } = require("./model.js")
 
-const { testLatency } = config
 const sleep = ms => new Promise(r => setTimeout(r, ms))
 
 definition.view({
   name: 'document',
+  accessControl: readerAccessControl,
   properties: {
-    document: {
-      type: Document,
+    targetType: {
+      type: String,
       validation: ['nonEmpty']
-    }
+    },
+    target: {
+      type: String,
+      validation: ['nonEmpty']
+    },
   },
   returns: {
     type: Document
@@ -28,9 +47,14 @@ definition.view({
 
 definition.view({
   name: 'steps',
+  accessControl: readerAccessControl,
   properties: {
-    document: {
-      type: Document,
+    targetType: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    target: {
+      type: String,
       validation: ['nonEmpty']
     },
     ...App.rangeProperties
@@ -43,7 +67,9 @@ definition.view({
   },
   async daoPath(props, { client, context }) {
     if(testLatency) await sleep(testLatency)
-    const path = StepsBucket.rangePath([props.document], App.extractRange(props))
+    const { targetType, target } = props
+    const document = App.encodeIdentifier([targetType, target])
+    const path = StepsBucket.rangePath([document], App.extractRange(props))
     console.log("PATH", path)
     return path
   }
@@ -51,56 +77,57 @@ definition.view({
 
 definition.view({
   name: 'snapshot',
+  accessControl: readerAccessControl,
   properties: {
-    document: {
-      type: Document,
+    targetType: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    target: {
+      type: String,
       validation: ['nonEmpty']
     },
     version: {
       type: Number
     }
   },
-  async daoPath({ document, version }, { client, context }) {
-    return Snapshot.path( App.encodeIdentifier([props.document,version.toFixed().padStart(10, '0')]) )
+  async daoPath({ targetType, target, version }, { client, context }) {
+    const document = App.encodeIdentifier([targetType, target])
+    return Snapshot.path( App.encodeIdentifier([document,version.toFixed().padStart(10, '0')]) )
   }
 })
 
 definition.view({
   name: 'snapshots',
+  accessControl: readerAccessControl,
   properties: {
-    document: {
-      type: Document,
+    targetType: {
+      type: String,
       validation: ['nonEmpty']
     },
-    ...App.rangeProperties
-  },
-  async daoPath({ document, version }, { client, context }) {
-    return Snapshot.indexRangePath( [document], App.extractRange(props) )
-  }
-})
-
-definition.view({
-  name: 'snapshots',
-  properties: {
-    document: {
-      type: Document,
+    target: {
+      type: String,
       validation: ['nonEmpty']
     },
-    version: {
-      type: Number
-    }
+    ...App.rangeProperties
   },
-  async daoPath({ document, version }, { client, context }) {
-    Snapshot.limitedRangePath([props.document], { limit: 10 })
-    return Snapshot.path( App.encodeIdentifier([props.document,version.toFixed().padStart(10, '0')]) )
+  async daoPath({ targetType, target, version }, { client, context }) {
+    const document = App.encodeIdentifier([targetType, target])
+    return Snapshot.indexRangePath( [document], App.extractRange(props) )
   }
 })
 
 definition.action({
   name: 'createDocument',
+  accessControl: writerAccessControl,
   waitForEvents: true,
+  queuedBy: ['targetType', 'target'],
   properties: {
-    document: {
+    targetType: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    target: {
       type: String,
       validation: ['nonEmpty']
     },
@@ -116,9 +143,11 @@ definition.action({
       type: Object
     }
   },
-  async execute({ document, type, purpose, content }, { client, service }, emit) {
+  queuedBy: (command) => [command.targetType, command.target],
+  async execute({ targetType, target, type, purpose, content }, { client, service }, emit) {
     if(testLatency) await sleep(testLatency)
     if(!schemas[type]) throw new Error(`schema not found for document type ${type}`)
+    const document = App.encodeIdentifier([targetType, target])
     const documentData = await Document.get(document)
     if(documentData) throw new Error('document already exists')
     emit({
@@ -127,16 +156,22 @@ definition.action({
     })
     return {
       id: document,
-      type, purpose, content, version: 0
+      type, purpose, content, version: 1
     }
   }
 })
 
 definition.action({
   name: 'createDocumentIfNotExists',
+  accessControl: writerAccessControl,
   waitForEvents: true,
+  queuedBy: ['targetType', 'target'],
   properties: {
-    document: {
+    targetType: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    target: {
       type: String,
       validation: ['nonEmpty']
     },
@@ -152,9 +187,11 @@ definition.action({
       type: Object
     }
   },
-  async execute({ document, type, purpose, content }, { client, service }, emit) {
+  queuedBy: (command) => [command.targetType, command.target],
+  async execute({ targetType, target, type, purpose, content }, { client, service }, emit) {
     if(testLatency) await sleep(testLatency)
     if(!schemas[type]) throw new Error(`schema not found for document type ${type}`)
+    const document = App.encodeIdentifier([targetType, target])
     const documentData = await Document.get(document)
     if(documentData) {
       return documentData
@@ -165,19 +202,25 @@ definition.action({
     })
     return {
       id: document,
-      type, purpose, content, version: 0
+      type, purpose, content, version: 1
     }
   }
 })
 
 definition.action({
-  name: 'doSteps',
+  name: 'edit',
+  accessControl: writerAccessControl,
   waitForEvents: true,
+  queuedBy: ['targetType', 'target'],
   properties: {
-    document: {
+    targetType: {
       type: String,
       validation: ['nonEmpty']
     },
+    target: {
+      type: String,
+        validation: ['nonEmpty']
+    },
     type: {
       type: String,
       validation: ['nonEmpty']
@@ -197,27 +240,31 @@ definition.action({
       type: Boolean
     }
   },
-  queuedBy: (command) => command.client.document,
-  async execute({ document, type, version, steps, window, continuation }, { client, service }, emit) {
+  queuedBy: (command) => [command.targetType, command.target],
+  async execute({ targetType, target, type, version, steps, window, continuation }, { client, service }, emit) {
     if(testLatency) await sleep(testLatency)
     if(!schemas[type]) throw new Error(`schema not found for document type ${type}`)
-    const documentData = await getDocument(document, type)
-    if(!documentData) throw new Error('document not found')
-    if(documentData.version != version) return 'ignored'
+    const document = App.encodeIdentifier([targetType, target])
+    const openDocument = await getDocument(document, type)
+    if(!openDocument) throw new Error('document not found')
+    console.log("EDIT DOCUMENT", openDocument.version, 'WITH', version)
+    if(openDocument.version != version) {
+      console.error("WRONG VERSION", openDocument.version, '!=', version)
+      return 'rejected'
+    }
     const [sessionOrUserType, sessionOrUser] =
       client.user ? ['user_User', client.user] : ['session_Session', client.session]
     if(continuation) {
       //console.log("DOC DATA", documentData)
       //console.log("CONTINUATION", documentData.lastStepsBucket, sessionOrUserType, sessionOrUser)
-      if(!documentData.lastStepsBucket
-          || documentData.lastStepsBucket.sessionOrUserType != sessionOrUserType
-          || documentData.lastStepsBucket.sessionOrUser != sessionOrUser
-          || documentData.lastStepsBucket.window != window) {
+      if(!openDocument.lastStepsBucket
+          || openDocument.lastStepsBucket.sessionOrUserType != sessionOrUserType
+          || openDocument.lastStepsBucket.sessionOrUser != sessionOrUser
+          || openDocument.lastStepsBucket.window != window) {
         console.log("CONTINUATION IGNORED!!")
-        return [] // ignore, client will rebase
+        return 'rejected' // ignore, client will rebase
       }
     }
-
     emit({
       type: 'documentEdited',
       document, documentType: type, version, steps, window,
@@ -225,15 +272,21 @@ definition.action({
       sessionOrUser,
       timestamp: new Date()
     })
-    return 'processed'
+    return 'saved'
   }
 })
 
 definition.action({
   name: 'takeSnapshot',
+  accessControl: writerAccessControl,
   waitForEvents: true,
+  queuedBy: ['targetType', 'target'],
   properties: {
-    document: {
+    targetType: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    target: {
       type: String,
       validation: ['nonEmpty']
     },
@@ -245,9 +298,10 @@ definition.action({
       type: Number
     },
   },
-  queuedBy: (command) => command.client.document,
-  async execute({ document, type, version }, { client, service }, emit) {
+  queuedBy: (command) => [command.targetType, command.target],
+  async execute({ targetType, target, type, version }, { client, service }, emit) {
     if(!schemas[type]) throw new Error(`schema not found for document type ${type}`)
+    const document = App.encodeIdentifier([targetType, target])
     const documentData = await getDocument(document, type)
     if(!documentData) throw new Error('document not found')
     if(typeof version != 'number') version = documentData.version
@@ -264,12 +318,17 @@ definition.action({
 definition.trigger({
   name: 'takeSnapshot',
   waitForEvents: true,
+  queuedBy: ['targetType', 'target'],
   properties: {
-    document: {
+    targetType: {
       type: String,
       validation: ['nonEmpty']
     },
-    type: {
+    target: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    documentType: {
       type: String,
       validation: ['nonEmpty']
     },
@@ -277,17 +336,19 @@ definition.trigger({
       type: Number
     },
   },
-  queuedBy: (command) => command.client.document,
-  async execute({ document, type, version }, { client, service }, emit) {
-    if(!schemas[type]) throw new Error(`schema not found for document type ${type}`)
-    const documentData = await getDocument(document, type)
+  queuedBy: (command) => [command.targetType, command.target],
+  async execute({ targetType, target, documentType, version }, { client, service }, emit) {
+    if(!schemas[documentType]) throw new Error(`schema not found for document type ${documentType}`)
+    const document = App.encodeIdentifier([targetType, target])
+    const documentData = await getDocument(document, documentType)
     if(!documentData) throw new Error('document not found')
     if(typeof version != 'number') version = documentData.version
+    if(version > documentData.version) throw new Error("version not found")
     const snapshot = App.encodeIdentifier([document, version.toFixed().padStart(10, '0')])
     emit({
       type: 'snapshotTaken',
       snapshot,
-      document, documentType: type, version
+      document, documentType, version
     })
     return snapshot
   }

package/model.js

@@ -121,7 +121,7 @@ async function getDocument(documentId, documentType) {
 definition.event({
   name: "documentCreated",
   async execute({ document, documentType, purpose, content, created, lastModified }) {
-    const version = 0
+    const version = 1
     await Document.create({ id: document, type: documentType, purpose, content, created, lastModified, version })
     await Snapshot.create({ id: App.encodeIdentifier([document, version.toFixed().padStart(10, '0')]),
         document, version, content, timestamp: lastModified })
@@ -199,7 +199,8 @@ definition.event({
     if(!openDocument) throw new Error('critical error - document not found') /// impossible
     if(openDocument.version < version)
       throw new Error('critical error - document version is lower than snapshot version') /// impossible
-    const existing = Snapshot.get(id)
+    const existing = await Snapshot.get(id)
+    console.log("SNAP", existing, openDocument.version, version)
     if(existing) return id
     if(openDocument.version == version) {
       const content = openDocument.content

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/prosemirror-service",
-  "version": "0.2.51",
+  "version": "0.3.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,12 +21,12 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "0.6.14",
-    "@live-change/relations-plugin": "0.6.14",
+    "@live-change/framework": "0.7.2",
+    "@live-change/relations-plugin": "0.7.2",
     "lru-cache": "^7.12.0",
     "pluralize": "8.0.0",
     "progress-stream": "^2.0.0",
     "prosemirror-model": "^1.18.1"
   },
-  "gitHead": "0f25467a8e4d5050355b407aca0060b08824f024"
+  "gitHead": "9cb5f8b01ecbcf4d841274ae112872370ea9d927"
 }