@nxtedition/lib 14.0.6 → 14.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "14.0.6",
+  "version": "14.0.8",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "files": [

package/serializers.js

@@ -173,6 +173,8 @@ function errSerializer(err) {
         if (key !== 'cause' && !Object.prototype.hasOwnProperty.call(val, seen)) {
           _err[key] = errSerializer(val)
         }
+      } else if (key === 'data' && typeof val !== 'string') {
+        _err[key] = JSON.stringify(val)
       } else {
         _err[key] = val
       }

package/trace.js

@@ -44,7 +44,7 @@ module.exports = function ({
     traceData = ''
 
     if (pending > limit / 4) {
-      logger.warn('throttling')
+      logger.warn('throttling tracing')
       if (pending > limit) {
         sleep(1000)
       } else if (pending > limit / 2) {

package/util/template/index.js

@@ -4,6 +4,8 @@ const fp = require('lodash/fp')
 const getNxtpressionsCompiler = require('./nextpressions')
 const getJavascriptCompiler = require('./javascript')
 const JSON5 = require('json5')
+const objectHash = require('object-hash')
+const weakCache = require('../../weakCache')
 
 module.exports = (options) => {
   const compilers = {
@@ -11,7 +13,36 @@ module.exports = (options) => {
     js: getJavascriptCompiler(options),
   }
 
-  const compileArrayTemplate = (arr, args$) => {
+  function inner(str) {
+    const templateStart = str.lastIndexOf('{{')
+    if (templateStart === -1) {
+      return null
+    }
+    let bodyStart = templateStart + 2
+
+    let templateEnd = str.indexOf('}}', templateStart + 2)
+    if (templateEnd === -1) {
+      return null
+    }
+    const bodyEnd = templateEnd
+    templateEnd += 2
+
+    let type = 'nxt'
+    if (str[bodyStart] === '#') {
+      type = str.slice(bodyStart + 1).match(/^([a-z]*)/)[1]
+      bodyStart += type.length + 1
+    }
+
+    return {
+      input: str,
+      pre: str.slice(0, templateStart),
+      type,
+      body: str.slice(bodyStart, bodyEnd),
+      post: str.slice(templateEnd),
+    }
+  }
+
+  function compileArrayTemplate(arr) {
     if (!fp.isArray(arr)) {
       throw new Error('invalid argument')
     }
@@ -20,7 +51,7 @@ module.exports = (options) => {
     let indices
 
     for (let i = 0; i < arr.length; i++) {
-      const resolver = compileTemplate(arr[i], args$)
+      const resolver = _compileTemplate(arr[i])
       if (resolver) {
         resolvers ??= []
         resolvers.push(resolver)
@@ -30,19 +61,20 @@ module.exports = (options) => {
     }
 
     return resolvers
-      ? rxjs.combineLatest(resolvers).pipe(
-          rx.map((values) => {
-            const ret = [...arr]
-            for (let n = 0; n < values.length; n++) {
-              ret[indices[n]] = values[n]
-            }
-            return ret
-          })
-        )
+      ? (args$) =>
+          rxjs.combineLatest(resolvers.map((resolver) => resolver(args$))).pipe(
+            rx.map((values) => {
+              const ret = [...arr]
+              for (let n = 0; n < values.length; n++) {
+                ret[indices[n]] = values[n]
+              }
+              return ret
+            })
+          )
       : null
   }
 
-  const compileObjectTemplate = (obj, args$) => {
+  function compileObjectTemplate(obj) {
     if (!fp.isPlainObject(obj)) {
       throw new Error('invalid argument')
     }
@@ -53,7 +85,7 @@ module.exports = (options) => {
     const keys = Object.keys(obj)
 
     for (let i = 0; i < keys.length; i++) {
-      const resolver = compileTemplate(obj[keys[i]], args$)
+      const resolver = _compileTemplate(obj[keys[i]])
       if (resolver) {
         resolvers ??= []
         resolvers.push(resolver)
@@ -63,48 +95,20 @@ module.exports = (options) => {
     }
 
     return resolvers
-      ? rxjs.combineLatest(resolvers).pipe(
-          rx.map((values) => {
-            const ret = { ...obj }
-            for (let n = 0; n < values.length; n++) {
-              ret[indices[n]] = values[n]
-            }
-            return ret
-          })
-        )
+      ? (args$) =>
+          rxjs.combineLatest(resolvers.map((resolver) => resolver(args$))).pipe(
+            rx.map((values) => {
+              const ret = { ...obj }
+              for (let n = 0; n < values.length; n++) {
+                ret[indices[n]] = values[n]
+              }
+              return ret
+            })
+          )
       : null
   }
 
-  const inner = function inner(str) {
-    const templateStart = str.lastIndexOf('{{')
-    if (templateStart === -1) {
-      return null
-    }
-    let bodyStart = templateStart + 2
-
-    let templateEnd = str.indexOf('}}', templateStart + 2)
-    if (templateEnd === -1) {
-      return null
-    }
-    const bodyEnd = templateEnd
-    templateEnd += 2
-
-    let type = 'nxt'
-    if (str[bodyStart] === '#') {
-      type = str.slice(bodyStart + 1).match(/^([a-z]*)/)[1]
-      bodyStart += type.length + 1
-    }
-
-    return {
-      input: str,
-      pre: str.slice(0, templateStart),
-      type,
-      body: str.slice(bodyStart, bodyEnd),
-      post: str.slice(templateEnd),
-    }
-  }
-
-  function compileStringTemplate(str, args$) {
+  function compileStringTemplate(str) {
     if (!fp.isString(str)) {
       throw new Error('invalid argument')
     }
@@ -124,15 +128,16 @@ module.exports = (options) => {
     const expr = compileExpression(body)
 
     if (!pre && !post) {
-      return expr(args$)
+      return (args$) => expr(args$)
     }
 
-    return expr(args$).pipe(
-      rx.switchMap((body) => {
-        const str = `${pre}${stringify(body, type !== 'js')}${post}`
-        return compileStringTemplate(str, args$) ?? rxjs.of(str)
-      })
-    )
+    return (args$) =>
+      expr(args$).pipe(
+        rx.switchMap((body) => {
+          const str = `${pre}${stringify(body, type !== 'js')}${post}`
+          return compileStringTemplate(str)?.(args$) ?? rxjs.of(str)
+        })
+      )
   }
 
   function stringify(value, escape) {
@@ -150,29 +155,58 @@ module.exports = (options) => {
     return typeof val === 'string' && val.indexOf('{{') !== -1
   }
 
-  function compileTemplate(template, args$) {
+  function hashTemplate(template, prefix) {
     if (fp.isPlainObject(template)) {
-      return compileObjectTemplate(template, args$)
+      let hashes
+      for (const key of Object.keys(template)) {
+        const hash = hashTemplate(template[key], key)
+        if (hash) {
+          hashes ??= []
+          hashes.push(hash)
+        }
+      }
+      return hashes ? objectHash([prefix, hashes]) : ''
     } else if (fp.isArray(template)) {
-      return compileArrayTemplate(template, args$)
-    } else if (fp.isString(template)) {
-      return compileStringTemplate(template, args$)
+      let hashes
+      for (let idx = 0; idx < template.length; idx++) {
+        const hash = hashTemplate(template[idx], idx)
+        if (hash) {
+          hashes ??= []
+          hashes.push(hash)
+        }
+      }
+      return hashes ? objectHash([prefix, hashes]) : ''
+    } else if (isTemplate(template)) {
+      return objectHash([prefix, template])
+    } else {
+      return ''
+    }
+  }
+
+  function _compileTemplate(template) {
+    if (fp.isPlainObject(template)) {
+      return compileObjectTemplate(template)
+    } else if (fp.isArray(template)) {
+      return compileArrayTemplate(template)
+    } else if (isTemplate(template)) {
+      return compileStringTemplate(template)
     } else {
       return null
     }
   }
 
+  const compileTemplate = weakCache(
+    (template) => _compileTemplate(template),
+    (template) => hashTemplate(template)
+  )
+
   async function resolveTemplate(template, args$) {
     return rxjs.firstValueFrom(onResolveTemplate(template, args$))
   }
 
   function onResolveTemplate(template, args$) {
-    if (fp.isString(template) && template.lastIndexOf('{{') === -1) {
-      return rxjs.of(template)
-    }
-
     try {
-      return compileTemplate(template, args$) ?? rxjs.of(template)
+      return compileTemplate(template)?.(args$) ?? rxjs.of(template)
     } catch (err) {
       return rxjs.throwError(() => err)
     }