@naanlang/naan 1.4.4 → 1.6.0

package/frameworks/service/model.nlg

@@ -0,0 +1,71 @@
+/*
+ * model.nlg
+ * Naanlib/frameworks/service
+ *
+ * Naan service model.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2023-2026 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * ServiceModel
+ *
+ * Model object for services, such as instance management. This is used to conceal architectural
+ * details from service users.
+ *
+ */
+
+closure ServiceModel(local model) {
+    global()
+    model = new(object, this)
+    model@\.class = new(object)
+
+    // add
+    //
+    // Add a location to our model with the specified name.
+    //
+    model@\.class.add = function add(name, local node) {
+        if !string(name) || name.trim() == ""
+            throw("ServiceModel.add: invalid name")
+        node = new(object)
+        node.id = name
+        node.parent = self
+        node@\.parent = self
+        self[name] = node
+        node
+    }
+    
+    // children
+    //
+    // List the ids of the children of the specified location, which is false for the root.
+    //
+    model@\.class.children = function children(parent) {
+        self.*.toarray.filter(function(id) { !id.startsWith(".") })
+    }
+
+    // finis
+
+    model
+};
+
+
+/*
+ * modelInit
+ *
+ * Initialize the component.
+ *
+ */
+
+function modelInit(local manifest) {
+    manifest = `(ServiceModel, modelInit)
+
+    Naan.module.build(module.id, "model", function(modobj, compobj) {
+        require("./service.nlg")
+        compobj.manifest = manifest
+        modobj.exports.ServiceModel = ServiceModel
+    })
+} ();

package/frameworks/service/nubnode.nlg

@@ -0,0 +1,105 @@
+/*
+ * nubnode.nlg
+ * Naanlib/frameworks/service
+ *
+ * Nub for node worker access to IMP.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2026 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * NodeWorkerNub
+ *
+ * NodeWorkerNub provides an IMP interface that runs on node workers. This allows the worker to
+ * communicate with the IMP network and the main thread. The worker IMP must be created before this.
+ *
+ */
+
+closure NodeWorkerNub(imp, options, local nownub) {
+    global(App,js)
+    if App.workerNub
+        return (App.workerNub)                                              // singleton
+
+    options = merge({
+        name: "NodeWorkerNub"
+        type: "node-worker-nub"
+    }, options)
+    nownub = new(object, this)
+    nownub.instanceID = imp.us.instanceID || UUID()
+    nownub.dispatcher = require("naanlib:frameworks/running/taskexec.nlg").TaskDispatcher()
+
+    // impReceive
+    //
+    // Receive a remote request and reply to it.
+    //
+    nownub.impReceive = function impReceive(message, sourceID) {
+        if message.id == "targetin"
+            nownub.dispatcher(message.data, function(reply) {
+                nownub.sender(sourceID, {
+                    id: "targetout",
+                    data: reply
+                })
+            })
+    }
+            
+    // impUnknown
+    //
+    // Received an unknown destination notice from the other side.
+    //
+    nownub.impUnknown = function impUnknown(unknownID, sourceID, gateway) {
+        if !gateway
+            debuglog("NodeWorkerNub.impUnknownID:", unknownID, "sourceID:", sourceID)
+    }
+
+    // message event
+    //
+    // Incoming data.
+    //
+    js.t.msgPort.on("message", function(msg) {
+        if msg.id == "naan-imp-node"
+            nownub.impconn.dispatch(new(msg.data))
+    })
+
+    // register our connects *after* the receivers are configured above
+
+    nownub.sender = imp.register(nownub, {
+        name: options.name
+        type: options.type
+        meta: options.meta || undefined
+        instanceID: nownub.instanceID
+        services: [ "naan-node-worker" ]
+    })
+    nownub.impconn = imp.requester(function(data) {
+        js.t.msgPort.postMessage({                                          // send to main
+            id: "naan-imp-node",
+            data: data
+        })
+        list(false, { sent: true })
+    })
+
+    // finis
+    
+    App.workerNub = nownub
+};
+
+
+/*
+ * nubnoInit
+ *
+ * Initialize the component.
+ *
+ */
+
+function nubnoInit(local manifest) {
+    manifest = `(NodeWorkerNub, nubnoInit)
+
+    Naan.module.build(module.id, "nubnode", function(modobj, compobj) {
+        require("./service.nlg")
+        compobj.manifest = manifest
+        modobj.exports.NodeWorkerNub = NodeWorkerNub
+    })
+} ();

package/frameworks/service/nubweb.nlg

@@ -0,0 +1,106 @@
+/*
+ * nubweb.nlg
+ * Naanlib/frameworks/service
+ *
+ * Nub for web worker access to IMP.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2026 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * WebWorkerNub
+ *
+ * WebWorkerNub provides an IMP interface that runs on web workers. This allows the worker to
+ * communicate with the IMP network and the main thread. The worker IMP must be created before this.
+ *
+ */
+
+closure WebWorkerNub(imp, options, local wonub) {
+    global(App,js)
+    if App.workerNub
+        return (App.workerNub)                                              // singleton
+
+    options = merge({
+        name: "WebWorkerNub"
+        type: "web-worker-nub"
+    }, options)
+    wonub = new(object, this)
+    wonub.instanceID = imp.us.instanceID || UUID()
+    wonub.dispatcher = require("naanlib:frameworks/running/taskexec.nlg").TaskDispatcher()
+
+    // impReceive
+    //
+    // Receive a remote request and reply to it.
+    //
+    wonub.impReceive = function impReceive(message, sourceID) {
+        if message.id == "targetin"
+            wonub.dispatcher(message.data, function(reply) {
+                wonub.sender(sourceID, {
+                    id: "targetout",
+                    data: reply
+                })
+            })
+    }
+            
+    // impUnknown
+    //
+    // Received an unknown destination notice from the other side.
+    //
+    wonub.impUnknown = function impUnknown(unknownID, sourceID, gateway) {
+        if !gateway
+            debuglog("WebWorkerNub.impUnknownID:", unknownID, "sourceID:", sourceID)
+    }
+
+    // message event
+    //
+    // Incoming data.
+    //
+    js.w.addEventListener("message", function message(e, local msg) {
+        msg = new(e.data)
+        if msg.scope == "naan-imp-web"
+            wonub.impconn.dispatch(msg.data)
+    })
+
+    // register our connects *after* the receivers are configured above
+
+    wonub.sender = imp.register(wonub, {
+        name: options.name
+        type: options.type
+        meta: options.meta || undefined
+        instanceID: wonub.instanceID
+        services: [ "naan-web-worker" ]
+    })
+    wonub.impconn = imp.requester(function(data) {
+        js.w.postMessage({                                                  // send to main
+            scope: "naan-imp-web",
+            data: data
+        })
+        list(false, { sent: true })
+    })
+
+    // finis
+    
+    App.workerNub = wonub
+};
+
+
+/*
+ * nubweInit
+ *
+ * Initialize the component.
+ *
+ */
+
+function nubweInit(local manifest) {
+    manifest = `(WebWorkerNub, nubweInit)
+
+    Naan.module.build(module.id, "nubweb", function(modobj, compobj) {
+        require("./service.nlg")
+        compobj.manifest = manifest
+        modobj.exports.WebWorkerNub = WebWorkerNub
+    })
+} ();

package/frameworks/service/service.nlg

@@ -0,0 +1,28 @@
+/*
+ * service.nlg
+ * Naanlib/frameworks/service
+ *
+ *     Root component for services functionality.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2026 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * svcInit
+ *
+ * Initialize the service module.
+ *
+ */
+
+function svcInit(local manifest) {
+    manifest = `(svcInit)
+
+    Naan.module.build(module.id, "service", function(modobj, compobj) {
+        require("../common/common.nlg").LiveImport()
+        compobj.manifest = manifest
+    })
+} ();

package/frameworks/storage/dbt_pouch.nlg

@@ -7,7 +7,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2024 by Richard C. Zulch
+ * Copyright (c) 2017-2025 by Richard C. Zulch
  *
  */
 
@@ -76,21 +76,31 @@ closure dapoTable(database, rootpath, local table, prefix) {
 
     // add
     //
-    // Add a new record to the table with optional metadata. This will fail if the key already
-    // exists. Returns the new document record.
-
-    table.add = closure add(key, content, metadata, callback, local id, doc) {
+    // Add a new record to the table with options. This will fail if the key already exists. Optional
+    // metadata is stored with the record and cannot be changed without calling update. Metadata keys
+    // cannot begin with underscore ("_").
+    //
+    // The returned document, which can be used with update, has the following keys:
+    //      key         - the key name of the record
+    //      content     - the body content stored under in the record
+    //      _md5        - the MD5 hash of the content
+    //      _length     - the length of the content
+    //      _id         - the PouchDB ID
+    //      _rev        - the PouchDB revision
+    //      <...>       - various metadata keys
+
+    table.add = closure add(key, content, options, callback, local id, doc) {
         if !callback
-            return (syncAdapter(add, key, content, metadata))
+            return (syncAdapter(add, key, content, options))
         id = makeID(key)
         if !string(id)
             return (asyncResult(callback, id))                              // error from makeID
-        if metadata && !dictionary(metadata)
+        if  options.metadata && !dictionary(options.metadata)
             return (asyncResult(callback, Error("invalid arguments")))
         if !database.pouch
             return (asyncResult(callback, Error("database closed")))
-        if metadata {
-            doc = new(metadata)                                             // start with metadata
+        if options.metadata {
+            doc = new(options.metadata)                                     // start with metadata
             doc._rev = undefined }                                          // _rev not allowed in metadata
         else
             doc = { }
@@ -115,12 +125,13 @@ closure dapoTable(database, rootpath, local table, prefix) {
 
     // update
     //
-    // Update a record in the table using the document previously returned by add or get.
-    // This will fail if the record has been modified by someone else in the meantime.
+    // Update a record in the table using the document previously returned by add or get. Specify
+    // options to update those values, otherwise existing/default values are used. This will fail
+    // if the record has been modified by someone else in the meantime.
 
-    table.update = closure update(doc, callback) {
+    table.update = closure update(doc, options, callback) {
         if !callback
-            return (syncAdapter(update, doc))
+            return (syncAdapter(update, doc, options))
         if !doc._id || !doc._id.startsWith(table.prefix) || !doc._rev
             return (asyncResult(callback, Error("invalid argument")))
         if makeID(doc.key) != doc._id
@@ -130,6 +141,8 @@ closure dapoTable(database, rootpath, local table, prefix) {
         doc = new(doc)
         doc._md5 = undefined
         doc._length = undefined
+        if options.metadata
+            doc = merge(doc, options.metadata)
         database.pouch.put(doc, function(error, resp) {
             if error
                 error = Error("update failed", error)

package/frameworks/storage/psm.nlg

@@ -252,6 +252,14 @@ closure MakePSMutil(fs, local util) {
     //      follow:     <boolean>           -- follow links instead of treating them as files
     //      idmode:     <boolean>           -- preserve id/mode where possible
     //      times:      <boolean>           -- preserve time where possible
+    //      cacheControl: [
+    //          {                           -- apply cacheControl to files matching regex
+    //              match: <regex-string>
+    //              flags: <regex-flags>    -- default "i" ignore case
+    //              cacheControl: <string>
+    //          }
+    //          ...
+    //      ]
     // }
     //
     // Limitations:
@@ -295,10 +303,13 @@ closure MakePSMutil(fs, local util) {
             if destpath == "."
                 destpath = ""                                               // joined empty strings
             `(error, stat) = fs.info(srcpath, fsopt)
-            if stat.type != "directory" && (!options.follow || stat.type != "symlink") {
+            if stat.type == "symlink" && options.follow && !fs.dirList(srcpath).0
+                stat.type = "directory"                                     // for our purposes this is a directory
+            if stat.type != "directory" {
                 copies.push({                                               // copy file or symlink 
                     source: srcpath
                     dest: destpath
+                    entry: entry
                 })
                 return (list(false, { ok: true }))                          // generic success not used
             }
@@ -346,10 +357,29 @@ closure MakePSMutil(fs, local util) {
             }).wait()
         }
         //
+        // Pass 3 - determine cache control values
+        //
+        let (regexes, item, file) {
+            regexes = new(options.cacheControl)
+            try {
+                for item in regexes
+                    item.regex = RegExp(item.match, item.flags || "i")
+            } catch {
+                ErrorDebuglog("PsmUtil.deepcopy: RegExp exception", exception)
+                regexes = []
+            }
+            for file in copies
+                for item in regexes
+                    if item.regex.test(file.entry) {
+                        file.cacheControl = item.cacheControl
+                        break
+                    }
+        } ()
+        //
         // Pass 3 - copy files and links
         //
         asyncArray(copies, 10, closure cpfiles(entry, 
-            local error, data, dest, instat, outstat) {
+            local error, data, dest, instat, outstat, foptions) {
             `(error, instat) = fs.info(entry.source, fsopt)
             if !error {
                 `(error, outstat) = outfs.info(entry.dest)
@@ -372,9 +402,13 @@ closure MakePSMutil(fs, local util) {
                         `(error, data) = outfs.symlink(data, entry.dest)
                 }
                 else {
-                    `(error, data) = fs.readFile(entry.source, { encoding: "binary"})
-                    if !error
-                        `(error, data) = outfs.writeFile(entry.dest, data, { encoding: "binary"})
+                    foptions = { encoding: "binary"}
+                    `(error, data) = fs.readFile(entry.source, foptions)
+                    if !error {
+                        if entry.cacheControl
+                            foptions.cacheControl = entry.cacheControl
+                        `(error, data) = outfs.writeFile(entry.dest, data, foptions)
+                    }
                     if !error && (options.idmode || options.times) {
                         if !options.idmode
                             instat.mode = instat.uid = instat.gid = false

package/frameworks/storage/psm_dbtables.nlg

@@ -185,6 +185,7 @@ closure FSview(table, rootpath, local view) {
     //      emptyok: true           -- allow empty directory names (leading "/" or embdedded "//")
     //      md5: <hash>             -- existing file content must match hash
     //      writenew: true          -- write as a new file, with updated create time
+    //      cacheControl: <string>  -- set the cacheControl header
     
    closure dbWriteRecord(path, content, options, callback) {
         if !callback
@@ -247,9 +248,15 @@ closure FSview(table, rootpath, local view) {
                     path: path
                 })))
             if doc
-                `(error, data) = view.table.update(doc)                     // update existing record
+                `(error, data) = view.table.update(doc, {                   // update existing record
+                    metadata: metadata
+                    cacheControl: options.cacheControl
+                })
             else
-                `(error, data) = view.table.add(path, content, metadata)    // create new record
+                `(error, data) = view.table.add(path, content, {            // create new record
+                    metadata: metadata
+                    cacheControl: options.cacheControl
+                })
             if error
                 callback(error)
             else
@@ -553,6 +560,7 @@ closure FSview(table, rootpath, local view) {
     // available:
     //      exclusive: true         -- file must not already exist
     //      md5: <hash>             -- existing file content must match hash
+    //      cacheControl: <string>  -- set the cacheControl header (if supported by underlying storage)
     
     view.write = closure write(path, content, options, callback) {
         if !callback