@live-change/prosemirror-service 0.2.38

package/definition.js

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

package/index.js

@@ -0,0 +1,120 @@
+const App = require("@live-change/framework")
+const app = App.app()
+
+const definition = require('./definition.js')
+
+const { Document, StepsBucket, schemas } = require("./model.js")
+
+definition.view({
+  name: 'document',
+  properties: {
+    document: {
+      type: Document,
+      validation: ['nonEmpty']
+    }
+  },
+  returns: {
+    type: Document
+  },
+  daoPath({ document }, { client, context }) {
+    return Document.path( document )
+  }
+})
+
+definition.view({
+  name: 'steps',
+  properties: {
+    document: {
+      type: Document,
+      validation: ['nonEmpty']
+    },
+    ...App.rangeProperties
+  },
+  returns: {
+    type: Array,
+    of: {
+      type: StepsBucket
+    }
+  },
+  daoPath(props, { client, context }) {
+    const path = StepsBucket.rangePath([props.document], App.extractRange(props))
+    console.log("PATH", path)
+    return path
+  }
+})
+
+definition.action({
+  name: 'createDocument',
+  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(!schemas[type]) throw new Error(`schema not found for document type ${type}`)
+    const documentData = await Document.get(document)
+    if(documentData) throw new Error('document already exists')
+    emit({
+      type: 'documentCreated',
+      document, documentType: type, purpose, content, lastModified: new Date(), created: new Date()
+    })
+  }
+})
+
+definition.action({
+  name: 'doSteps',
+  waitForEvents: true,
+  properties: {
+    document: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    type: {
+      type: String,
+      validation: ['nonEmpty']
+    },
+    version: {
+      type: Number
+    },
+    steps: {
+      type: Array,
+      validation: ['nonEmpty']
+    },
+    window: {
+      type: String,
+      validation: ['nonEmpty']
+    }
+  },
+  queuedBy: (command) => command.client.document,
+  async execute({ document, type, version, steps, window }, { client, service }, emit) {
+    if(!schemas[type]) throw new Error(`schema not found for document type ${type}`)
+    const documentData = await Document.get(document)
+    if(!documentData) throw new Error('document not found')
+    if(document.version > version) return 'ignored'
+    const [sessionOrUserType, sessionOrUser] =
+      client.user ? ['user_User', client.user] : ['session_Session', client.session]
+    emit({
+      type: 'documentEdited',
+      document, documentType: type, version, steps, window,
+      sessionOrUserType,
+      sessionOrUser,
+      timestamp: new Date()
+    })
+    return 'processed'
+  }
+})
+
+module.exports = definition

package/model.js

@@ -0,0 +1,121 @@
+const App = require("@live-change/framework")
+const app = App.app()
+const definition = require('./definition.js')
+const config = definition.config
+const LRU = require('lru-cache')
+const { Schema } = require('prosemirror-model')
+const { Step } = require('prosemirror-transform')
+
+const Document = definition.model({
+  name: 'Document',
+  properties: {
+    type: {
+      type: String
+    },
+    purpose: {
+      type: String
+    },
+    version: {
+      type: Number
+    },
+    content: {
+      type: Object
+    },
+    created: {
+      type: Date
+    },
+    lastModified: {
+      type: Date
+    }
+  }
+})
+
+const StepsBucket = definition.model({
+  name: 'StepsBucket',
+  properties: {
+    steps: {
+      type: Object
+    },
+    sessionOrUserType: {
+      type: String
+    },
+    sessionOrUser: {
+      type: String
+    },
+    window: {
+      type: String
+    },
+    timestamp: {
+      type: Date
+    }
+  }
+})
+
+const schemas = {}
+for(const typeName in config.documentTypes) {
+  const spec = config.documentTypes[typeName]
+  schemas[typeName] = new Schema(spec)
+}
+
+const openDocuments = new LRU({
+  max: 500,
+  maxSize: 10e6,
+  sizeCalculation: (value, key) => value.content.nodeSize,
+  ttl: 1000 * 60 * 5,
+})
+
+async function getDocument(documentId, documentType) {
+  const schema = schemas[documentType]
+  if(!schema) throw new Error(`schema not found for document type ${documentType}`)
+  let document = openDocuments.get(documentId)
+  if(!document) {
+    const documentData = await Document.get(documentId)
+    if(!documentData) {
+      return null
+    }
+    document = {
+      type: documentData.type,
+      content: schema.nodeFromJSON(documentData.content),
+      version: documentData.version,
+      schema
+    }
+    openDocuments.set(documentId, document)
+  }
+  if(document.type != documentType) throw new Error("wrong document type!")
+  return document
+}
+
+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 })
+  }
+})
+
+definition.event({
+  name: "documentEdited",
+  async execute({ document, documentType, version, steps, window, sessionOrUserType, sessionOrUser, timestamp }) {
+    const openDocument = await getDocument(document, documentType)
+    if(!openDocument) throw new Error('critical error - document not found') /// impossible
+    if(openDocument.version != version) return // ignore, client will rebase
+    for(const stepJson of steps) {
+      const step = Step.fromJSON(openDocument.schema, stepJson)
+      openDocument.content = step.apply(openDocument.content).doc
+      openDocument.version ++
+    }
+    await Promise.all([
+      Document.update(document, {
+        content: openDocument.content.toJSON(),
+        version: openDocument.version,
+        lastModified: timestamp
+      }),
+      StepsBucket.create({
+        id: App.encodeIdentifier([document, openDocument.version.toFixed().padStart(10, '0')]),
+        window, sessionOrUserType, sessionOrUser, timestamp: new Date(),
+        steps
+      })
+    ])
+  }
+})
+
+module.exports = { Document, StepsBucket, schemas }

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@live-change/prosemirror-service",
+  "version": "0.2.38",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "NODE_ENV=test tape tests/*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/live-change/live-change-services.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/live-change/live-change-services/issues"
+  },
+  "homepage": "https://github.com/live-change/live-change-services",
+  "author": {
+    "email": "michal@laszczewski.pl",
+    "name": "Michał Łaszczewski",
+    "url": "https://www.viamage.com/"
+  },
+  "dependencies": {
+    "@live-change/framework": "0.6.5",
+    "@live-change/relations-plugin": "0.6.5",
+    "lru-cache": "^7.12.0",
+    "pluralize": "8.0.0",
+    "progress-stream": "^2.0.0",
+    "prosemirror-model": "^1.18.1"
+  },
+  "gitHead": "d30c93533192fb0d3b620929c61c5d04568beae0"
+}