@muze-nl/simplystore 0.5.2 → 0.5.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@muze-nl/simplystore",
-	"version": "0.5.2",
+	"version": "0.5.4",
 	"main": "src/server.mjs",
 	"type": "module",
 	"scripts": {

package/src/command-worker-module.mjs

@@ -1,5 +1,5 @@
 import JSONTag from '@muze-nl/jsontag'
-import {source} from './symbols.mjs'
+import {source, isChanged} from './symbols.mjs'
 import fastParse from './fastParse.mjs'
 import {stringToSAB,resultSetStringify} from './fastStringify.mjs'
 import writeFileAtomic from 'write-file-atomic'
@@ -25,7 +25,7 @@ export const metaIdProxy = {
         })
     },
     set: (id,ref) => {
-        //FICME: is this correct?
+        //FIXME: is this correct?
         meta.index.id.set(id, resultSet.length-1)
     },
     get: (id) => {
@@ -46,7 +46,10 @@ export const metaIdProxy = {
 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),
+    setAttribute: (obj, attr, value) => {
+        obj[isChanged] = true
+        return JSONTag.setAttribute(obj[source], attr, value)
+    },
     getAttributes: (obj) => JSONTag.getAttributes(obj[source]),
     getAttributeString: (obj) => JSONTag.getAttributesString(obj[source]),
     getTypeString: (obj) => JSONTag.getTypeString(obj[source])
@@ -59,6 +62,7 @@ export async function initialize(task) {
     metaProxy.index.id = metaIdProxy
     datafile = task.datafile
     commands = await import(task.commandsFile).then(mod => {
+        console.log('commands loaded:',Object.keys(mod.default))
         return mod.default
     })
 }
@@ -71,29 +75,28 @@ export default async function runCommand(commandStr, request) {
         jsontag: true
     }
     if (commands[task.name]) {
-        try {
-            commands[task.name](dataspace, task, request, metaProxy)
-            FastJSONTag.setAttribute(dataspace, 'command', task.id)
+        let time = Date.now()
+        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
-                }
+        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}'
         }
+
+        await writeFileAtomic(datafile, uint8sab)
+        let end = Date.now()
+        console.log('task time',end-time)
     } 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}'
+        console.error('Command not found', task.name)
+        throw {
+            code: 404,
+            message: "Command "+task.name+" not found"
+        }
     }
     return response
 }

package/src/command-worker.mjs

@@ -3,11 +3,7 @@ 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 }
-    }
+    await initialize(data)
+    result = await runCommand(data.command)
     parentPort.postMessage(result)
 })

package/src/fastParse.mjs

@@ -567,9 +567,9 @@ export default function parse(input, meta, immutable=true)
         error("Input stopped early")
     }
 
-    let object = function()
+    let object = function(object={})
     {
-        let key, val, object={}
+        let key, val
         if (ch !== '{') {
             error("Syntax Error")
         }
@@ -638,10 +638,10 @@ export default function parse(input, meta, immutable=true)
         return parseInt(numString)
     }
 
-    let parseValue = function(position) {
+    let parseValue = function(position, ob={}) {
         at = position.start
         next()
-        return value()
+        return value(ob)
     }
 
     const makeChildProxies = function(parent) {
@@ -704,7 +704,7 @@ export default function parse(input, meta, immutable=true)
                             if (i != index) {
                                 return encoder.encode('~'+index)
                             }
-                            // return newly stringified contents of cache
+                            // return newly stringified contents of target
                             return encoder.encode(fastStringify(target, meta, true, i))
                         }
                     break
@@ -726,7 +726,7 @@ export default function parse(input, meta, immutable=true)
                 if (JSONTag.getType(value)==='object' && !value[isProxy]) {
                     value = getNewValueProxy(value)
                 }
-                cache[prop] = val
+                target[prop] = val
                 return true                    
             }
         }
@@ -749,6 +749,12 @@ export default function parse(input, meta, immutable=true)
         let parsed = false
         at += length
         next()
+        let firstParse = function() {
+            if (!parsed) {
+                parseValue(position, cache)
+                parsed = true
+            }
+        }
         // newValueHandler makes sure that value[getBuffer] runs stringify
         // arrayHandler makes sure that changes in the array set targetIsChanged to true
         let arrayHandler = {
@@ -794,13 +800,10 @@ export default function parse(input, meta, immutable=true)
         }
         let handler = {
             get(target, prop, receiver) {
-                if (!parsed) {
-                    cache = parseValue(position)
-                    parsed = true
-                }
+                firstParse()
                 switch(prop) {
                     case source:
-                        return cache
+                        return target
                     break
                     case isProxy:
                         return true
@@ -812,8 +815,8 @@ export default function parse(input, meta, immutable=true)
                             }
                             if (targetIsChanged) {
                                 // return newly stringified contents of cache
-                                let temp = fastStringify(cache, null, true)
-                                return encoder.encode(fastStringify(cache, null, true))
+                                let temp = fastStringify(target, null, true)
+                                return encoder.encode(fastStringify(target, null, true))
                             }
                             return input.slice(position.start,position.end)
                         }
@@ -825,57 +828,43 @@ export default function parse(input, meta, immutable=true)
                         return targetIsChanged
                     break
                     default:
-                        if (!immutable && Array.isArray(cache[prop])) {
-                            return new Proxy(cache[prop], arrayHandler)
+                        if (!immutable && Array.isArray(target[prop])) {
+                            return new Proxy(target[prop], arrayHandler)
                         }
-                        return cache[prop] // FIXME: make arrays immutable as well
+                        return target[prop] // FIXME: make arrays immutable as well
                     break
                 }
             },
-            has(target, prop) {
-                if (!parsed) {
-                    cache = parseValue(position)
-                    parsed = true
-                }
-                return typeof cache[prop] !== 'undefined'
-            },
-            ownKeys() {
-                if (!parsed) {
-                    cache = parseValue(position)
-                    parsed = true
-                }
-                return Reflect.ownKeys(cache)
-            }
-        }
-        if (!immutable) {
-            Object.assign(handler, {
-                set: (target, prop, val) => {
-                    if (!parsed) {
-                        cache = parseValue(position)
-                        parsed = true
-                    }
-                    if (JSONTag.getType(val)==='object' && !val[isProxy]) {
-                        val = getNewValueProxy(val)
+            set(target, prop, value) {
+                if (!immutable) {
+                    firstParse()
+                    if (prop!==isChanged) {
+                        if (JSONTag.getType(value)==='object' && !value[isProxy]) {
+                            value = getNewValueProxy(value)
+                        }
+                        target[prop] = value
                     }
-                    cache[prop] = val
                     targetIsChanged = true
                     return true
-                },
-                deleteProperty: (target, prop) => {
-                    if (!parsed) {
-                        cache = parseValue(position)
-                        parsed = true
-                    }
-                    delete cache[prop]
+                }
+            },
+            deleteProperty: (target, prop) => {
+                if (!immutable) {
+                    firstParse()
+                    delete target[prop]
                     targetIsChanged = true
                     return true
                 }
-            })
+            },
+            'ownKeys': (target) => {
+                firstParse()
+                return Reflect.ownKeys(target)
+            }
         }
         return new Proxy(cache, handler)
     }
 
-    value = function()
+    value = function(ob={})
     {
         let tagOb, result, tagName;
         whitespace()
@@ -893,7 +882,7 @@ export default function parse(input, meta, immutable=true)
                 if (tagName && tagName!=='object') {
                     isTypeError(tagName, ch)
                 }
-                result = object()
+                result = object(ob)
             break
             case '[':
                 if (tagName && tagName!=='array') {

package/src/server.mjs

@@ -153,7 +153,7 @@ async function main(options) {
                 let lines = file.split("\n").filter(Boolean) //filter clears empty lines
                 for(let line of lines) {
                     let command = JSONTag.parse(line)
-                    status.set(command.id, command.status)
+                    status.set(command.id, command)
                 }
             }
         }
@@ -208,31 +208,38 @@ async function main(options) {
             start(
                 // resolve()
                 (data) => {
-                    if (!data || data.error) {
-                        console.error('ERROR: SimplyStore cannot run command ', command.id, err)
-                        if (!data.error) {
-                            status.set(command.id, 'failed')
-                            throw new Error('Unexpected command failure')
+                    let s
+                    if (!data || (data.code>=300 && data.code<=499)) {
+                        console.error('ERROR: SimplyStore cannot run command ', command.id, data)
+                        if (!data?.code) {
+                            s = {code: 500, status: "failed"}
                         } else {
-                            status.set(command.id, data.error)
-                            throw data.error
+                            s = {code: data.code, status: "failed", message: data.message, details: data.details}
+                        }
+                        status.set(command.id, s)
+                    } else {
+                        s = {code: 200, status: "done"}
+                        status.set(command.id, s)
+                        if (data.data) { // data has changed, commands may do other things instead of changing data
+                            jsontagBuffer = data.data
+                            meta = data.meta
+                            // restart query workers with new data
+                            let oldPool = queryWorkerPool
+                            queryWorkerPool = new WorkerPool(maxWorkers, queryWorker, queryWorkerInitTask())
+                            setTimeout(() => {
+                                oldPool.close()
+                            }, 2000)
                         }
                     }
-                    jsontagBuffer = data.data
-                    meta = data.meta
-                    status.set(command.id, 'done')
-                    appendFile(commandStatus, JSONTag.stringify({command:command.id, status: 'done'}))
-                    // restart query workers with new data
-                    let oldPool = queryWorkerPool
-                    queryWorkerPool = new WorkerPool(maxWorkers, queryWorker, queryWorkerInitTask())
-                    setTimeout(() => {
-                        oldPool.close()
-                    }, 2000)
+                    let l = Object.assign({command:command.id}, s)
+                    console.log('appending status ',l,s)
+                    appendFile(commandStatus, JSONTag.stringify(Object.assign({command:command.id}, s)))
                 }, 
                 //reject()
                 (error) => {
-                    status.set(command.id, error)
-                    appendFile(commandStatus, JSONTag.stringify({command:command.id, status: error}))
+                    let s = {status: "failed", code: error.code, message: error.message, details: error.details}
+                    status.set(command.id, s)
+                    appendFile(commandStatus, JSONTag.stringify(Object.assign({command:command.id}, s)))
                 }
             )
         } else {
@@ -270,8 +277,9 @@ async function main(options) {
 
             runNextCommand()
         } catch(err) {
-            appendFile(commandStatus, JSONTag.stringify({command:commandId, status: 'ERROR: '+err.message}))
-            status.set(commandId, 'ERROR: '+err.message)
+            let s = {code:err.code||500, status:'failed', message:err.message, details:err.details}
+            status.set(commandId, s)
+            appendFile(commandStatus, JSONTag.stringify(Object.assign({command:commandId}, s)))
             console.error('ERROR: SimplyStore cannot run command ', commandId, err)
         }
     })
@@ -279,32 +287,35 @@ async function main(options) {
     function checkCommand(req, res) {
         let commandStr = req.body.toString() // raw body through express.raw()
         let command = JSONTag.parse(commandStr)
+        let commandOK = {
+            command: command?.id,
+            code: 202,
+            status: 'accepted'
+        }
         if (!command || !command.id) {
             error = {
                 code: 422,
-                message: "Command has no id"
+                message: "Command has no id",
+                details: command
             }
             sendResponse({code: 422, body: JSON.stringify(error)}, res)
             return false
         } else if (status.has(command.id)) {
-            result = "OK"
-            sendResponse({body: JSON.stringify(result)}, res)
+            sendResponse({body: JSON.stringify(s)}, res)
             return false
         } else if (!command.name) {
             error = {
                 code: 422,
-                message: "Command has no name"
+                message: "Command has no name",
+                details: command
             }
             sendResponse({code:422, body: JSON.stringify(error)}, res)
             return false      
         }
         appendFile(commandLog, JSONTag.stringify(command))
-        appendFile(commandStatus, JSONTag.stringify({
-            command: command.id,
-            status: 'accepted'
-        }))
-        status.set(command.id, 'accepted') 
-        sendResponse({code: 202, body: '"Accepted"'}, res)
+        appendFile(commandStatus, JSONTag.stringify(commandOK))
+        status.set(command.id, commandOK) 
+        sendResponse({code: 202, body: JSON.stringify(commandOK)}, res)
         return command.id
     }
 
@@ -319,7 +330,7 @@ async function main(options) {
             sendResponse({
                 code: 404,
                 jsontag: false,
-                body: JSON.stringify({code: 404, message: "Command not found"})
+                body: JSON.stringify({code: 404, message: "Command not found", details: req.params.id})
             }, res)
         }
     })