@jsreport/jsreport-core 4.1.0 → 4.2.0

package/lib/main/reporter.js

@@ -4,7 +4,6 @@
  * Reporter main class including all methods jsreport-core exposes.
  */
 const path = require('path')
-const { Readable } = require('stream')
 const Reaper = require('@jsreport/reap')
 const pkg = require('../../package.json')
 const optionsLoad = require('./optionsLoad')
@@ -27,7 +26,7 @@ const documentStoreActions = require('./store/mainActions')
 const blobStorageActions = require('./blobStorage/mainActions')
 const Reporter = require('../shared/reporter')
 const Request = require('./request')
-const generateRequestId = require('../shared/generateRequestId')
+const Response = require('../shared/response')
 const Profiler = require('./profiler')
 const semver = require('semver')
 let reportCounter = 0
@@ -370,7 +369,7 @@ class MainReporter extends Reporter {
 
     req = Object.assign({}, req)
     req.context = Object.assign({}, req.context)
-    req.context.rootId = req.context.rootId || generateRequestId()
+    req.context.rootId = req.context.rootId || this.generateRequestId()
     req.context.id = req.context.rootId
     req.context.reportCounter = ++reportCounter
     req.context.startTimestamp = new Date().getTime()
@@ -379,7 +378,9 @@ class MainReporter extends Reporter {
     let worker
     let workerAborted
     let dontCloseProcessing
-    const res = { meta: {} }
+
+    const res = Response(this, req.context.id)
+
     try {
       await this.beforeRenderWorkerAllocatedListeners.fire(req)
 
@@ -442,7 +443,8 @@ class MainReporter extends Reporter {
               worker
             }, req)
 
-            Object.assign(res, responseResult)
+            await res.parse(responseResult)
+
             await this.afterRenderListeners.fire(req, res)
           } catch (err) {
             await this._handleRenderError(req, res, err).catch((e) => {})
@@ -455,11 +457,11 @@ class MainReporter extends Reporter {
         })
 
         dontCloseProcessing = true
-        const r = {
-          ...req.context.clientNotification,
-          stream: Readable.from(req.context.clientNotification.content)
-        }
+
+        const r = req.context.clientNotification
+
         delete req.context.clientNotification
+
         return r
       }
 
@@ -472,16 +474,10 @@ class MainReporter extends Reporter {
         worker
       }, req)
 
-      Object.assign(res, responseResult)
+      await res.parse(responseResult)
 
       await this.afterRenderListeners.fire(req, res)
 
-      if (!res.content) {
-        this.logger.error('Worker didnt return render res.content, returned:' + JSON.stringify(responseResult), req)
-      }
-
-      res.stream = Readable.from(res.content)
-
       this._cleanProfileInRequest(req)
 
       return res
@@ -551,7 +547,7 @@ class MainReporter extends Reporter {
   }
 
   async executeWorkerAction (actionName, data, options = {}, req) {
-    req.context.rootId = req.context.rootId || generateRequestId()
+    req.context.rootId = req.context.rootId || this.generateRequestId()
     const timeout = options.timeout || 60000
 
     const worker = options.worker

package/lib/main/request.js

@@ -1,21 +1,30 @@
-const extend = require('node.extend.without.arrays')
+const Request = require('../shared/request')
 
 module.exports = (obj) => {
-  const request = Object.create({}, {
-    __isJsreportRequest__: {
-      value: true,
-      writable: false,
-      configurable: false,
-      enumerable: false
-    }
-  })
-
-  request.template = extend(true, {}, obj.template)
-
-  request.options = extend(true, {}, request.options, obj.options)
-  request.context = extend(true, {}, request.context, obj.context)
-  request.context.shared = extend(true, {}, request.context.shared)
-  request.data = obj.data
+  const targetObj = { ...obj }
+
+  const originalData = targetObj.data
+
+  delete targetObj.data
+
+  const customOriginalInputDataIsEmptyResult = {
+    defined: false,
+    value: null
+  }
+
+  if (targetObj?.context != null && Object.hasOwn(targetObj.context, 'originalInputDataIsEmpty')) {
+    customOriginalInputDataIsEmptyResult.defined = true
+    customOriginalInputDataIsEmptyResult.value = targetObj.context.originalInputDataIsEmpty
+  }
+
+  const request = Request(targetObj)
+  request.data = originalData
+
+  if (customOriginalInputDataIsEmptyResult.defined) {
+    request.context.originalInputDataIsEmpty = customOriginalInputDataIsEmptyResult.value
+  } else {
+    delete request.context.originalInputDataIsEmpty
+  }
 
   return request
 }

package/lib/shared/reporter.js

@@ -1,6 +1,7 @@
 const EventEmitter = require('events')
 const createListenerCollection = require('./listenerCollection')
 const Request = require('./request')
+const Response = require('./response')
 const Templates = require('./templates')
 const Folders = require('./folders')
 const createOrExtendError = require('./createError')
@@ -8,6 +9,7 @@ const tempFilesHandler = require('./tempFilesHandler')
 const encryption = require('./encryption')
 const generateRequestId = require('./generateRequestId')
 const adminRequest = require('./adminRequest')
+const ReqStorage = require('./reqStorage')
 
 class Reporter extends EventEmitter {
   constructor (options) {
@@ -15,7 +17,9 @@ class Reporter extends EventEmitter {
 
     this.options = options || {}
     this.Request = Request
+    this.Response = (...args) => Response(this, ...args)
     this.adminRequest = adminRequest
+    this.reqStorage = ReqStorage(this)
 
     // since `reporter` instance will be used for other extensions,
     // it will quickly reach the limit of `10` listeners,
@@ -82,6 +86,27 @@ class Reporter extends EventEmitter {
     return tempFilesHandler.ensureTempDirectoryExists(this.options.tempAutoCleanupDirectory)
   }
 
+  getTempFilePath (filename) {
+    if (this.options.tempAutoCleanupDirectory == null) {
+      throw new Error('Can not use getTempFilename when tempAutoCleanupDirectory option is not initialized, make sure to initialize jsreport first using jsreport.init()')
+    }
+
+    return tempFilesHandler.getTempFilePath(this.options.tempAutoCleanupDirectory, filename)
+  }
+
+  /**
+   * Synchronously reads a file from the jsreport auto-cleanup temp directory (options.tempAutoCleanupDirectory)
+   *
+   * @public
+   */
+  readTempFileSync (filename, opts) {
+    if (this.options.tempAutoCleanupDirectory == null) {
+      throw new Error('Can not use readTempFileSync when tempAutoCleanupDirectory option is not initialized, make sure to initialize jsreport first using jsreport.init()')
+    }
+
+    return tempFilesHandler.readTempFileSync(this.options.tempAutoCleanupDirectory, filename, opts)
+  }
+
   /**
    * Reads a file from the jsreport auto-cleanup temp directory (options.tempAutoCleanupDirectory)
    *
@@ -95,6 +120,33 @@ class Reporter extends EventEmitter {
     return tempFilesHandler.readTempFile(this.options.tempAutoCleanupDirectory, filename, opts)
   }
 
+  /**
+   * Open temp file in jsreport auto-cleanup temp directory (options.tempAutoCleanupDirectory)
+   *
+   * @public
+   */
+  async openTempFile (filename, flags) {
+    if (this.options.tempAutoCleanupDirectory == null) {
+      throw new Error('Can not use openTempFile when tempAutoCleanupDirectory option is not initialized, make sure to initialize jsreport first using jsreport.init()')
+    }
+
+    return tempFilesHandler.openTempFile(this.options.tempAutoCleanupDirectory, filename, flags)
+  }
+
+  /**
+   * Synchronously creates a file into the jsreport auto-cleanup temp directory (options.tempAutoCleanupDirectory)
+   * ensuring that the directory always exists
+   *
+   * @public
+   */
+  writeTempFileSync (filenameFn, content, opts) {
+    if (this.options.tempAutoCleanupDirectory == null) {
+      throw new Error('Can not use writeTempFileSync when tempAutoCleanupDirectory option is not initialized, make sure to initialize jsreport first using jsreport.init()')
+    }
+
+    return tempFilesHandler.writeTempFileSync(this.options.tempAutoCleanupDirectory, filenameFn, content, opts)
+  }
+
   /**
    * Creates a file into the jsreport auto-cleanup temp directory (options.tempAutoCleanupDirectory)
    * ensuring that the directory always exists
@@ -114,7 +166,7 @@ class Reporter extends EventEmitter {
    *
    * @public
    */
-  async readTempFileStream (filename, opts) {
+  readTempFileStream (filename, opts) {
     if (this.options.tempAutoCleanupDirectory == null) {
       throw new Error('Can not use readTempFileStream when tempAutoCleanupDirectory option is not initialized, make sure to initialize jsreport first using jsreport.init()')
     }
@@ -136,6 +188,20 @@ class Reporter extends EventEmitter {
     return tempFilesHandler.writeTempFileStream(this.options.tempAutoCleanupDirectory, filenameFn, opts)
   }
 
+  /**
+   * Copies a file into the jsreport auto-cleanup temp directory (options.tempAutoCleanupDirectory)
+   * ensuring that the directory always exists
+   *
+   * @public
+   */
+  async copyFileToTempFile (srcFilePath, destFilenameFn, mode) {
+    if (this.options.tempAutoCleanupDirectory == null) {
+      throw new Error('Can not use copyToTempFile when tempAutoCleanupDirectory option is not initialized, make sure to initialize jsreport first using jsreport.init()')
+    }
+
+    return tempFilesHandler.copyFileToTempFile(this.options.tempAutoCleanupDirectory, srcFilePath, destFilenameFn, mode)
+  }
+
   async init () {
     this.templates = Templates(this)
     this.folders = Folders(this)

package/lib/shared/reqStorage.js

@@ -0,0 +1,20 @@
+module.exports = (reporter) => {
+  const runningReqMap = new Map()
+
+  return {
+    set: (key, val, req) => {
+      const keyValueMap = runningReqMap.get(req.context.rootId)
+      keyValueMap.set(key, val)
+    },
+    get: (key, req) => {
+      const keyValueMap = runningReqMap.get(req.context.rootId)
+      return keyValueMap.get(key)
+    },
+    registerReq: (req) => {
+      runningReqMap.set(req.context.rootId, new Map())
+    },
+    unregisterReq: (req) => {
+      runningReqMap.delete(req.context.rootId)
+    }
+  }
+}

package/lib/shared/response.js

@@ -0,0 +1,231 @@
+const extend = require('node.extend.without.arrays')
+const fs = require('fs/promises')
+const { Readable } = require('stream')
+const { pipeline } = require('stream/promises')
+const path = require('path')
+const isArrayBufferView = require('util').types.isArrayBufferView
+
+module.exports = (reporter, requestId, obj) => {
+  let outputImpl = new BufferOutput(reporter)
+  let cachedStream
+
+  const response = {
+    meta: extend(true, {}, (obj || {}).meta),
+
+    /** back compatibility methods **/
+    get content () {
+      return outputImpl.getBufferSync()
+    },
+
+    set content (v) {
+      outputImpl.setBufferSync(Buffer.from(v))
+    },
+
+    get stream () {
+      if (cachedStream == null) {
+        cachedStream = outputImpl.getStream()
+      }
+
+      return cachedStream
+    },
+    /** //// back compatibility methods **/
+
+    get isInStreamingMode () {
+      return outputImpl instanceof StreamOutput
+    },
+
+    get __isJsreportResponse__ () {
+      return true
+    },
+
+    output: {
+      async getBuffer () { return outputImpl.getBuffer() },
+      async getStream () { return outputImpl.getStream() },
+      async getSize () { return outputImpl.getSize() },
+      async writeToTempFile (...args) { return outputImpl.writeToTempFile(...args) },
+      async update (bufOrStreamOrPath) {
+        if (Buffer.isBuffer(bufOrStreamOrPath) || isArrayBufferView(bufOrStreamOrPath)) {
+          return outputImpl.setBuffer(bufOrStreamOrPath)
+        }
+
+        if (typeof bufOrStreamOrPath === 'string') {
+          if (!path.isAbsolute(bufOrStreamOrPath)) {
+            throw new Error('Invalid content passed to res.output.update, when content is string it must be an absolute path')
+          }
+
+          if (outputImpl instanceof BufferOutput) {
+            outputImpl = new StreamOutput(reporter, requestId)
+          }
+
+          await reporter.copyFileToTempFile(bufOrStreamOrPath, outputImpl.filePath)
+          return
+        }
+
+        if (isReadableStream(bufOrStreamOrPath)) {
+          if (outputImpl instanceof BufferOutput) {
+            outputImpl = new StreamOutput(reporter, requestId)
+          }
+
+          return outputImpl.setStream(bufOrStreamOrPath)
+        }
+
+        throw new Error('Invalid content passed to res.output.update')
+      }
+    },
+
+    serialize () {
+      return {
+        meta: extend(true, {}, this.meta),
+        output: outputImpl.serialize()
+      }
+    },
+
+    async parse (res) {
+      Object.assign(this.meta, res.meta)
+
+      if (res.output.type === 'buffer') {
+        outputImpl = await BufferOutput.parse(reporter, res.output)
+      } else {
+        outputImpl = await StreamOutput.parse(reporter, requestId, res.output)
+      }
+    }
+  }
+
+  return response
+}
+
+class BufferOutput {
+  constructor (reporter) {
+    this.reporter = reporter
+    this.buffer = Buffer.from([])
+
+    this.getBufferSync = this.getBuffer
+    this.setBufferSync = this.setBuffer
+  }
+
+  getBuffer () {
+    return this.buffer
+  }
+
+  setBuffer (buf) {
+    // we need to ensure that the buffer is an actually buffer instance,
+    // so when receiving Uint8Array we convert it to a buffer
+    this.buffer = Buffer.isBuffer(buf) ? buf : Buffer.from(buf)
+  }
+
+  writeToTempFile (tmpNameFn) {
+    return this.reporter.writeTempFile(tmpNameFn, this.buffer)
+  }
+
+  getSize () {
+    return this.buffer.length
+  }
+
+  getStream () {
+    return Readable.from(this.buffer)
+  }
+
+  serialize () {
+    const sharedBuf = new SharedArrayBuffer(this.buffer.byteLength)
+    const buf = Buffer.from(sharedBuf)
+
+    this.buffer.copy(buf)
+
+    return {
+      type: 'buffer',
+      content: buf
+    }
+  }
+
+  static parse (reporter, output) {
+    const instance = new BufferOutput(reporter)
+    if (output?.content?.length) {
+      instance.setBufferSync(Buffer.from(output?.content))
+    }
+    return instance
+  }
+}
+
+class StreamOutput {
+  constructor (reporter, requestId) {
+    this.reporter = reporter
+    this.filename = `response-${requestId}.raw-content`
+    const { pathToFile } = this.reporter.getTempFilePath(this.filename)
+    this.filePath = pathToFile
+  }
+
+  async getBuffer () {
+    const { content } = await this.reporter.readTempFile(this.filename)
+    return content
+  }
+
+  setBuffer (buf) {
+    return this.reporter.writeTempFile(this.filename, buf)
+  }
+
+  getBufferSync () {
+    const { content } = this.reporter.readTempFileSync(this.filename)
+    return content
+  }
+
+  setBufferSync (buf) {
+    this.reporter.writeTempFileSync(this.filename, buf)
+  }
+
+  writeToTempFile (tmpNameFn) {
+    return this.reporter.copyFileToTempFile(this.filePath, tmpNameFn)
+  }
+
+  async getSize () {
+    const stat = await fs.stat(this.filePath)
+    return stat.size
+  }
+
+  getStream () {
+    const reporter = this.reporter
+    const filename = this.filename
+
+    async function * generateResponseContent () {
+      const responseFileStream = reporter.readTempFileStream(filename).stream
+
+      for await (const chunk of responseFileStream) {
+        yield chunk
+      }
+    }
+
+    // we produce a new Readable stream to avoid exposing the file stream directly
+    return Readable.from(generateResponseContent())
+  }
+
+  async setStream (stream) {
+    const { stream: responseFileStream } = await this.reporter.writeTempFileStream(this.filename)
+    await pipeline(stream, responseFileStream)
+  }
+
+  serialize () {
+    return {
+      type: 'stream',
+      filePath: this.filePath
+    }
+  }
+
+  static async parse (reporter, requestId, output) {
+    const instance = new StreamOutput(reporter, requestId)
+
+    if (output.filePath !== instance.filePath) {
+      await reporter.copyFileToTempFile(output.filePath, instance.filePath)
+    }
+    return instance
+  }
+}
+
+// from https://github.com/sindresorhus/is-stream/blob/main/index.js
+function isReadableStream (stream) {
+  return (
+    stream !== null &&
+    typeof stream === 'object' &&
+    typeof stream.pipe === 'function' &&
+    stream.readable !== false && typeof stream._read === 'function' &&
+    typeof stream._readableState === 'object'
+  )
+}

package/lib/shared/tempFilesHandler.js

@@ -13,8 +13,34 @@ module.exports.ensureTempDirectoryExists = async function (tempDirectory) {
   }
 }
 
+module.exports.getTempFilePath = getTempFilePath
+
+module.exports.readTempFileSync = function readTempFileSync (tempDirectory, filename, opts = {}) {
+  const { pathToFile } = getTempFilePath(tempDirectory, filename)
+
+  const content = fs.readFileSync(pathToFile, opts)
+
+  return {
+    pathToFile,
+    filename,
+    content
+  }
+}
+
+module.exports.openTempFile = async function (tempDirectory, filenameFn, flags) {
+  const { pathToFile, filename } = getTempFilePath(tempDirectory, filenameFn)
+
+  const fileHandle = await fsAsync.open(pathToFile, flags)
+
+  return {
+    pathToFile,
+    filename,
+    fileHandle
+  }
+}
+
 module.exports.readTempFile = async function readTempFile (tempDirectory, filename, opts = {}) {
-  const pathToFile = path.join(tempDirectory, filename)
+  const { pathToFile } = getTempFilePath(tempDirectory, filename)
 
   const content = await fsAsync.readFile(pathToFile, opts)
 
@@ -25,51 +51,91 @@ module.exports.readTempFile = async function readTempFile (tempDirectory, filena
   }
 }
 
-module.exports.readTempFileStream = async function readTempFileStream (tempDirectory, filename, opts = {}) {
-  const pathToFile = path.join(tempDirectory, filename)
+module.exports.readTempFileStream = function readTempFileStream (tempDirectory, filename, opts = {}) {
+  const { pathToFile } = getTempFilePath(tempDirectory, filename)
 
-  return new Promise((resolve) => {
-    const stream = fs.createReadStream(pathToFile, opts)
+  const stream = fs.createReadStream(pathToFile, opts)
 
-    resolve({
-      pathToFile,
-      filename,
-      stream
-    })
-  })
+  return {
+    pathToFile,
+    filename,
+    stream
+  }
+}
+
+module.exports.writeTempFileSync = function writeTempFileSync (tempDirectory, filenameOrFn, content, opts = {}) {
+  return writeFileSync(tempDirectory, filenameOrFn, content, opts)
 }
 
-module.exports.writeTempFile = async function writeTempFile (tempDirectory, filenameFn, content, opts = {}) {
-  return writeFile(tempDirectory, filenameFn, content, opts)
+module.exports.writeTempFile = async function writeTempFile (tempDirectory, filenameOrFn, content, opts = {}) {
+  return writeFile(tempDirectory, filenameOrFn, content, opts)
 }
 
-module.exports.writeTempFileStream = async function writeTempFileStream (tempDirectory, filenameFn, opts = {}) {
-  return writeFile(tempDirectory, filenameFn, undefined, opts, true)
+module.exports.writeTempFileStream = async function writeTempFileStream (tempDirectory, filenameOrFn, opts = {}) {
+  return writeFile(tempDirectory, filenameOrFn, undefined, opts, true)
 }
 
-async function writeFile (tempDirectory, filenameFn, content, opts, asStream = false) {
-  const filename = filenameFn(uuidv4())
+module.exports.copyFileToTempFile = async function copyFileToTempFile (tempDirectory, srcFilePath, destFilenameOrFn, mode) {
+  const { pathToFile, filename } = getTempFilePath(tempDirectory, destFilenameOrFn)
 
-  if (filename == null || filename === '') {
-    throw new Error('No valid filename was returned from filenameFn')
+  await fsAsync.mkdir(tempDirectory, {
+    recursive: true
+  })
+
+  await fsAsync.copyFile(srcFilePath, pathToFile, mode)
+
+  return {
+    pathToFile,
+    filename
+  }
+}
+
+function getTempFilePath (tempDirectory, filenameOrFn) {
+  const filenameResult = typeof filenameOrFn === 'function' ? filenameOrFn(uuidv4()) : filenameOrFn
+
+  if (filenameResult == null || filenameResult === '') {
+    throw new Error('No valid filename')
+  }
+
+  const pathToFile = path.isAbsolute(filenameResult) ? filenameResult : path.join(tempDirectory, filenameResult)
+  const filename = path.basename(pathToFile)
+
+  return {
+    pathToFile,
+    filename
+  }
+}
+
+function writeFileSync (tempDirectory, filenameOrFn, content, opts) {
+  const { pathToFile, filename } = getTempFilePath(tempDirectory, filenameOrFn)
+
+  fs.mkdirSync(tempDirectory, {
+    recursive: true
+  })
+
+  fs.writeFileSync(pathToFile, content, opts)
+
+  return {
+    pathToFile,
+    filename
   }
+}
 
-  const pathToFile = path.join(tempDirectory, filename)
+async function writeFile (tempDirectory, filenameOrFn, content, opts, asStream = false) {
+  const { pathToFile, filename } = getTempFilePath(tempDirectory, filenameOrFn)
 
   await fsAsync.mkdir(tempDirectory, {
     recursive: true
   })
 
   if (asStream === true) {
-    return new Promise((resolve) => {
-      const stream = fs.createWriteStream(pathToFile, opts)
-
-      resolve({
-        pathToFile,
-        filename,
-        stream
-      })
-    })
+    const stream = fs.createWriteStream(pathToFile, opts)
+
+    return {
+      pathToFile,
+      filename,
+      stream
+    }
   } else {
     await fsAsync.writeFile(pathToFile, content, opts)
 

package/lib/worker/defaultProxyExtend.js

@@ -12,10 +12,8 @@ module.exports = (reporter) => (proxy, req) => {
       context: {}
     }, req)
 
-    return {
-      content: res.content,
-      meta: res.meta
-    }
+    // expose the response api
+    return res
   }
 
   proxy.documentStore = {