@muze-nl/simplystore 0.4.6 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@muze-nl/simplystore",
-	"version": "0.4.6",
+	"version": "0.5.0",
 	"main": "src/server.mjs",
 	"type": "module",
 	"scripts": {
@@ -17,17 +17,25 @@
 	"homepage": "https://github.com/simplyedit/simplystore#readme",
 	"dependencies": {
 		"@muze-nl/jsontag": "^0.8.6",
-		"array-where-select": "^0.4.4",
+		"array-where-select": "^0.4.7",
 		"codemirror": "^6.0.1",
 		"express": "^4.18.1",
 		"json-pointer": "^0.6.2",
 		"jsonpath-plus": "^7.2.0",
 		"piscina": "^4.1.0",
-		"vm2": "^3.9.13"
+		"vm2": "^3.9.13",
+		"write-file-atomic": "^5.0.1"
 	},
 	"devDependencies": {
 		"eslint": "^8.48.0",
 		"process": "^0.11.10",
 		"tap": "^16.3.8"
-	}
+	},
+	"files": [
+		"README.md",
+		"LICENSE",
+		"src/",
+		"www/",
+		"scripts/"
+	]
 }

package/scripts/convert.mjs

@@ -0,0 +1,25 @@
+import JSONTag from '@muze-nl/jsontag'
+import fastStringify from '../src/fastStringify.mjs'
+import fs from 'node:fs'
+
+if (process.argv.length<=3) {
+	console.log('usage: node ./convert.mjs {inputfile} {outputfile}')
+	process.exit()
+}
+
+// parse command line
+let inputFile = process.argv[2]
+let outputFile = process.argv[3]
+
+// load file
+let input = fs.readFileSync(inputFile, 'utf-8')
+
+// parse jsontag
+let data = JSONTag.parse(input)
+
+// write resultset to output
+let strData = fastStringify(data)
+
+fs.writeFileSync(outputFile, strData)
+
+console.log('Converted data written to ',outputFile)

package/src/command-worker-module.mjs

@@ -0,0 +1,100 @@
+import JSONTag from '@muze-nl/jsontag'
+import {source} from './symbols.mjs'
+import fastParse from './fastParse.mjs'
+import {stringToSAB,resultSetStringify} from './fastStringify.mjs'
+import writeFileAtomic from 'write-file-atomic'
+
+let commands = {}
+let resultSet = []
+let dataspace
+let datafile
+let meta = {}
+let metaProxy = {
+    index: {
+    }
+}
+
+export const metaIdProxy = {
+    forEach: (callback) => {
+        meta.index.id.forEach((ref,id) => {
+            callback({
+                deref: () => {
+                    return resultSet[ref]
+                }
+            },id)
+        })
+    },
+    set: (id,ref) => {
+        //FICME: is this correct?
+        meta.index.id.set(id, resultSet.length-1)
+    },
+    get: (id) => {
+        let index = meta.index.id.get(id)
+        if (index || index===0) {
+            return {
+                deref: () => {
+                    return resultSet[index]
+                }
+            }
+        }
+    },
+    has: (id) => {
+        return meta.index.id.has(id)
+    }
+}
+
+export const FastJSONTag = {
+    getType: (obj) => JSONTag.getType(obj[source]),
+    getAttribute: (obj, attr) => JSONTag.getAttribute(obj[source],attr),
+    setAttribute: (obj, attr, value) => JSONTag.setAttribute(obj[source], attr, value),
+    getAttributes: (obj) => JSONTag.getAttributes(obj[source]),
+    getAttributeString: (obj) => JSONTag.getAttributesString(obj[source]),
+    getTypeString: (obj) => JSONTag.getTypeString(obj[source])
+}
+
+export async function initialize(task) {
+    resultSet = fastParse(task.data, task.meta, false) // false means mutable
+    dataspace = resultSet[0]
+    meta = task.meta
+    metaProxy.index.id = metaIdProxy
+    datafile = task.datafile
+    commands = await import(task.commandsFile).then(mod => {
+        return mod.default
+    })
+}
+
+export default async function runCommand(commandStr, request) {
+    let task = JSONTag.parse(commandStr, null, metaProxy)
+    if (!task.id) { throw new Error('missing command id')}
+    if (!task.name) { throw new Error('missing command name parameter')}
+    let response = {
+        jsontag: true
+    }
+    if (commands[task.name]) {
+        try {
+            commands[task.name](dataspace, task, request, metaProxy)
+            FastJSONTag.setAttribute(dataspace, 'command', task.id)
+
+            const strData = resultSetStringify(resultSet)
+            const uint8sab = stringToSAB(strData)
+            response.data = uint8sab
+            response.meta = {
+                index: {
+                    id: meta.index.id
+                }
+            }
+
+            await writeFileAtomic(datafile, uint8sab)
+        } catch(err) {
+            console.error('error',err)
+            response.code = 422;
+            response.body = '<object class="Error">{"message":'+JSON.stringify(''+err)+',"code":422}'
+        }
+    } else {
+        console.error('Command not found', task.name, commands)
+        response.code = 404
+        response.body = '<object class="Error">{"message":"Command '+task.name+' not found","code":404}'
+    }
+    return response
+}
+

package/src/command-worker.mjs

@@ -0,0 +1,13 @@
+import { parentPort } from 'node:worker_threads'
+import runCommand, { initialize } from '../src/command-worker-module.mjs' 
+
+parentPort.on('message', async data => {
+    let result
+    try {
+        await initialize(data)
+        result = await runCommand(data.command)
+    } catch(err) {
+        result = { error: err.message }
+    }
+    parentPort.postMessage(result)
+})