@live-change/prosemirror-service 0.2.47 → 0.2.49

package/index.js

@@ -4,7 +4,7 @@ const app = App.app()
 const definition = require('./definition.js')
 const config = definition.config
 
-const { Document, StepsBucket, schemas } = require("./model.js")
+const { Document, StepsBucket, schemas, getDocument } = require("./model.js")
 
 const { testLatency } = config
 const sleep = ms => new Promise(r => setTimeout(r, ms))
@@ -49,6 +49,53 @@ definition.view({
   }
 })
 
+definition.view({
+  name: 'snapshot',
+  properties: {
+    document: {
+      type: Document,
+      validation: ['nonEmpty']
+    },
+    version: {
+      type: Number
+    }
+  },
+  async daoPath({ document, version }, { client, context }) {
+    return Snapshot.path( App.encodeIdentifier([props.document,version.toFixed().padStart(10, '0')]) )
+  }
+})
+
+definition.view({
+  name: 'snapshots',
+  properties: {
+    document: {
+      type: Document,
+      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,
+      validation: ['nonEmpty']
+    },
+    version: {
+      type: Number
+    }
+  },
+  async daoPath({ document, version }, { client, context }) {
+    Snapshot.limitedRangePath([props.document], { limit: 10 })
+    return Snapshot.path( App.encodeIdentifier([props.document,version.toFixed().padStart(10, '0')]) )
+  }
+})
+
 definition.action({
   name: 'createDocument',
   waitForEvents: true,
@@ -78,6 +125,48 @@ definition.action({
       type: 'documentCreated',
       document, documentType: type, purpose, content, lastModified: new Date(), created: new Date()
     })
+    return {
+      id: document,
+      type, purpose, content, version: 0
+    }
+  }
+})
+
+definition.action({
+  name: 'createDocumentIfNotExists',
+  waitForEvents: true,
+  properties: {
+    document: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    type: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    purpose: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    content: {
+      type: Object
+    }
+  },
+  async execute({ document, 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 documentData = await Document.get(document)
+    if(documentData) {
+      return documentData
+    }
+    emit({
+      type: 'documentCreated',
+      document, documentType: type, purpose, content, lastModified: new Date(), created: new Date()
+    })
+    return {
+      id: document,
+      type, purpose, content, version: 0
+    }
   }
 })
 
@@ -103,17 +192,32 @@ definition.action({
     window: {
       type: String,
       validation: ['nonEmpty']
+    },
+    continuation: {
+      type: Boolean
     }
   },
   queuedBy: (command) => command.client.document,
-  async execute({ document, type, version, steps, window }, { client, service }, emit) {
+  async execute({ document, 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 Document.get(document)
+    const documentData = await getDocument(document, type)
     if(!documentData) throw new Error('document not found')
-    if(document.version > version) return 'ignored'
+    if(documentData.version != version) return 'ignored'
     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) {
+        console.log("CONTINUATION IGNORED!!")
+        return [] // ignore, client will rebase
+      }
+    }
+
     emit({
       type: 'documentEdited',
       document, documentType: type, version, steps, window,
@@ -125,4 +229,69 @@ definition.action({
   }
 })
 
+definition.action({
+  name: 'takeSnapshot',
+  waitForEvents: true,
+  properties: {
+    document: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    type: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    version: {
+      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)
+    if(!documentData) throw new Error('document not found')
+    if(typeof version != 'number') version = documentData.version
+    const snapshot = App.encodeIdentifier([document, version.toFixed().padStart(10, '0')])
+    emit({
+      type: 'snapshotTaken',
+      snapshot,
+      document, documentType: type, version
+    })
+    return snapshot
+  }
+})
+
+definition.trigger({
+  name: 'takeSnapshot',
+  waitForEvents: true,
+  properties: {
+    document: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    type: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    version: {
+      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)
+    if(!documentData) throw new Error('document not found')
+    if(typeof version != 'number') version = documentData.version
+    const snapshot = App.encodeIdentifier([document, version.toFixed().padStart(10, '0')])
+    emit({
+      type: 'snapshotTaken',
+      snapshot,
+      document, documentType: type, version
+    })
+    return snapshot
+  }
+})
+
+
 module.exports = definition

package/model.js

@@ -6,6 +6,8 @@ const LRU = require('lru-cache')
 const { Schema } = require('prosemirror-model')
 const { Step } = require('prosemirror-transform')
 
+const { snapshotAfterSteps = 230 } = config
+
 const Document = definition.model({
   name: 'Document',
   propertyOfAny: {
@@ -53,6 +55,29 @@ const StepsBucket = definition.model({
   }
 })
 
+const Snapshot = definition.model({
+  name: 'Snapshot',
+  properties: {
+    document: {
+      type: String
+    },
+    version: {
+      type: Number
+    },
+    content: {
+      type: Object
+    },
+    timestamp: {
+      type: Date
+    }
+  },
+  indexes: {
+    list: {
+      property: ['document', 'version']
+    }
+  }
+})
+
 const schemas = {}
 for(const typeName in config.documentTypes) {
   const spec = config.documentTypes[typeName]
@@ -75,10 +100,16 @@ async function getDocument(documentId, documentType) {
     if(!documentData) {
       return null
     }
+    const [lastStepsBucket, lastSnapshot] = await Promise.all([
+      StepsBucket.rangeGet([documentId], { reverse: true, limit: 1 }).then(x => x?.[0] ?? null),
+      Snapshot.rangeGet([documentId], { reverse: true, limit: 1 }).then(x => x?.[0] ?? null)
+    ])
     document = {
       type: documentData.type,
       content: schema.nodeFromJSON(documentData.content),
       version: documentData.version,
+      lastStepsBucket,
+      lastSnapshot,
       schema
     }
     openDocuments.set(documentId, document)
@@ -90,7 +121,10 @@ async function getDocument(documentId, documentType) {
 definition.event({
   name: "documentCreated",
   async execute({ document, documentType, purpose, content, created, lastModified }) {
-    await Document.create({ id: document, type: documentType, purpose, content, created, lastModified, version: 0 })
+    const version = 0
+    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 })
   }
 })
 
@@ -105,19 +139,80 @@ definition.event({
       openDocument.content = step.apply(openDocument.content).doc
       openDocument.version ++
     }
-    await Promise.all([
+    const bucket = {
+      id: App.encodeIdentifier([document, openDocument.version.toFixed().padStart(10, '0')]),
+      window, sessionOrUserType, sessionOrUser, timestamp: new Date(),
+      steps
+    }
+    //console.log("DOC EDITED", bucket)
+    const content =  openDocument.content.toJSON()
+    openDocument.lastStepsBucket = bucket
+    const promises = [
       Document.update(document, {
-        content: openDocument.content.toJSON(),
+        content,
         version: openDocument.version,
         lastModified: timestamp
       }),
-      StepsBucket.create({
+      StepsBucket.create(bucket)
+    ]
+    if(openDocument.lastSnapshot.version < openDocument.version - snapshotAfterSteps) {
+      openDocument.lastSnapshot = {
         id: App.encodeIdentifier([document, openDocument.version.toFixed().padStart(10, '0')]),
-        window, sessionOrUserType, sessionOrUser, timestamp: new Date(),
-        steps
-      })
-    ])
+        document, version: openDocument.version, content, timestamp
+      }
+      promises.push(Snapshot.create(openDocument.lastSnapshot))
+    }
+    await Promise.all(promises)
+  }
+})
+
+async function readVersion(document, documentType, version) {
+  const schema = schemas[documentType]
+  const snapshot = await Snapshot.rangePath([document], {
+    reverse: true, limit: 1, lte: version.toFixed().padStart(10, '0')
+  })?.[0]
+  if(!snapshot) throw 'not_found'
+  let content = schema.nodeFromJSON(snapshot.content)
+  let current = snapshot.version
+  while(current < version) {
+    const stepsBuckets = await StepsBucket.rangePath([document], {
+      gt: current.toFixed().padStart(10, '0')
+    })
+    for(const stepsBucket of stepsBuckets) {
+      for(const stepJson of stepsBucket.steps) {
+        const step = Step.fromJSON(schemas[snapshot.type], stepJson)
+        content = step.apply(content).doc
+        current ++
+        if(current == version) return {
+          content,
+          timestamp: stepsBuckets.timestamp
+        }
+      }
+    }
+  }
+}
+
+definition.event({
+  name: "snapshotTaken",
+  async execute({ snapshot: id, document, documentType, version }) {
+    const openDocument = await getDocument(document, documentType)
+    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)
+    if(existing) return id
+    if(openDocument.version == version) {
+      const content = openDocument.content
+      const snapshot = { id, document, version, content, timestamp: openDocument.lastModified }
+      await Snapshot.create(snapshot)
+      if(version > openDocument.lastSnapshot.version) openDocument.lastSnapshot = snapshot
+    } else {
+      const { content, timestamp } = readVersion(document, documentType, version)
+      const snapshot = { id, document, version, content, timestamp }
+      await Snapshot.create(snapshot)
+      if(version > openDocument.lastSnapshot.version) openDocument.lastSnapshot = snapshot
+    }
   }
 })
 
-module.exports = { Document, StepsBucket, schemas }
+module.exports = { Document, StepsBucket, schemas, getDocument, readVersion }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/prosemirror-service",
-  "version": "0.2.47",
+  "version": "0.2.49",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -28,5 +28,5 @@
     "progress-stream": "^2.0.0",
     "prosemirror-model": "^1.18.1"
   },
-  "gitHead": "710dc205163bf09d6b9469822101e9dfc11b74cb"
+  "gitHead": "f95b94a51d134dda63ab6f8a42b16a9b26c5dbfb"
 }