@jsreport/jsreport-core 3.0.1 → 3.1.2-test.2

package/lib/main/extensions/findVersion.js

@@ -1,53 +1,49 @@
-const path = require('path')
-const fsAsync = require('fs/promises')
-
-module.exports = async (extension) => {
-  const result = {
-    source: 'anonymous'
-  }
-
-  if (extension.version != null || extension.source != null) {
-    result.source = extension.source
-    result.version = extension.version
-    result.pkgVersion = extension.pkgVersion
-
-    return result
-  }
-
-  if (extension.name == null) {
-    return result
-  }
-
-  if (extension.directory == null) {
-    result.source = 'local'
-    result.version = 'local:inline'
-    return result
-  }
-
-  try {
-    const packageJsonContent = await fsAsync.readFile(path.join(extension.directory, 'package.json'))
-    const packageJson = JSON.parse(packageJsonContent.toString())
-
-    if (packageJson._requested && packageJson._requested.type === 'git') {
-      result.source = 'git'
-      result.version = packageJson._resolved
-      result.pkgVersion = packageJson.version
-    } else if (packageJson._requested && packageJson.version != null) {
-      result.source = 'npm'
-      result.version = packageJson.version
-      result.pkgVersion = packageJson.version
-    } else if (packageJson.version != null) {
-      result.source = 'local'
-      result.version = `local:${extension.directory}:${packageJson.version}`
-      result.pkgVersion = packageJson.version
-    } else {
-      result.source = 'local'
-      result.version = `local:${extension.directory}`
-    }
-  } catch (e) {
-    result.source = 'local'
-    result.version = `local:${extension.directory}`
-  }
-
-  return result
-}
+const path = require('path')
+const fsAsync = require('fs/promises')
+
+module.exports = async (extension) => {
+  const result = {
+    source: 'anonymous'
+  }
+
+  if (extension.version != null || extension.source != null) {
+    result.source = extension.source
+    result.version = extension.version
+    result.pkgVersion = extension.pkgVersion
+
+    return result
+  }
+
+  if (extension.name == null) {
+    return result
+  }
+
+  if (extension.directory == null) {
+    result.source = 'local'
+    result.version = 'local:inline'
+    return result
+  }
+
+  try {
+    const packageJsonContent = await fsAsync.readFile(path.join(extension.directory, 'package.json'))
+    const packageJson = JSON.parse(packageJsonContent.toString())
+
+    if (extension.directory.includes('node_modules') && packageJson.version != null) {
+      result.source = 'npm'
+      result.version = packageJson.version
+      result.pkgVersion = packageJson.version
+    } else if (packageJson.version != null) {
+      result.source = 'local'
+      result.version = `local:${extension.directory}:${packageJson.version}`
+      result.pkgVersion = packageJson.version
+    } else {
+      result.source = 'local'
+      result.version = `local:${extension.directory}`
+    }
+  } catch (e) {
+    result.source = 'local'
+    result.version = `local:${extension.directory}`
+  }
+
+  return result
+}

package/lib/main/extensions/locationCache.js

@@ -1,97 +1,103 @@
-const path = require('path')
-const fs = require('fs/promises')
-const fileUtils = require('./fileUtils')
-
-module.exports = (config) => {
-  const cacheEntryRootPath = path.join(__dirname, '../../../../')
-  const pathToLocationCache = path.join(config.tempCoreDirectory, 'locations.json')
-
-  return {
-    async get () {
-      if (process.env.NODE_ENV === 'jsreport-development' || config.useExtensionsLocationCache === false) {
-        config.logger.info('Skipping extensions location cache when NODE_ENV=jsreport-development or when option useExtensionsLocationCache === false, crawling now')
-
-        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
-      }
-
-      try {
-        await fs.stat(pathToLocationCache)
-      } catch (e) {
-        config.logger.info('Extensions location cache not found, crawling directories')
-        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
-      }
-
-      const content = await fs.readFile(pathToLocationCache, 'utf8')
-
-      let cache
-
-      try {
-        cache = JSON.parse(content)[cacheEntryRootPath]
-      } catch (e) {
-        // file is corrupted, nevermind and crawl the extensions
-      }
-
-      if (!cache) {
-        config.logger.info('Extensions location cache doesn\'t contain entry yet, crawling')
-        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
-      }
-
-      if (cache.rootDirectory !== config.rootDirectory) {
-        config.logger.info(`Extensions location cache ${pathToLocationCache} contains information with different rootDirectory, crawling`)
-        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
-      }
-
-      const stat = await fs.stat(cacheEntryRootPath)
-
-      if (stat.mtime.getTime() > cache.lastSync) {
-        config.logger.info(`Extensions location cache ${pathToLocationCache} contains older information, crawling`)
-        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
-      }
-
-      await Promise.all(cache.locations.map((l) => fs.stat(l)))
-
-      config.logger.info(`Extensions location cache contains up to date information, skipping crawling in ${config.rootDirectory}`)
-
-      const directories = fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js', cacheEntryRootPath)
-      const result = directories.concat(cache.locations)
-
-      return result
-    },
-
-    async save (extensions) {
-      const directories = (
-        extensions
-          .map((e) => path.join(e.directory, 'jsreport.config.js'))
-          .filter((d) => d.indexOf(cacheEntryRootPath) !== -1)
-      )
-
-      await fs.mkdir(config.tempCoreDirectory, { recursive: true })
-
-      try {
-        await fs.stat(pathToLocationCache)
-      } catch (e) {
-        await fs.writeFile(pathToLocationCache, JSON.stringify({}), 'utf8')
-      }
-
-      const content = await fs.readFile(pathToLocationCache, 'utf8')
-
-      let nodes = {}
-
-      try {
-        nodes = JSON.parse(content)
-      } catch (e) {
-        // file is corrupted, nevermind and override all
-      }
-
-      nodes[cacheEntryRootPath] = {
-        rootDirectory: config.rootDirectory,
-        locations: directories,
-        lastSync: new Date().getTime()
-      }
-
-      config.logger.debug(`Writing extension locations cache to ${pathToLocationCache}`)
-
-      return fs.writeFile(pathToLocationCache, JSON.stringify(nodes), 'utf8')
-    }
-  }
-}
+const path = require('path')
+const fs = require('fs/promises')
+const fileUtils = require('./fileUtils')
+
+module.exports = (config) => {
+  // we want to have as cache entry the node_modules folder
+  const cacheEntryRootPath = path.join(__dirname, '../../../../../')
+  const pathToLocationCache = path.join(config.tempCoreDirectory, 'locations.json')
+
+  return {
+    async get () {
+      if (process.env.NODE_ENV === 'jsreport-development' || config.useExtensionsLocationCache === false) {
+        config.logger.info('Skipping extensions location cache when NODE_ENV=jsreport-development or when option useExtensionsLocationCache === false, crawling now')
+
+        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
+      }
+
+      try {
+        await fs.stat(pathToLocationCache)
+      } catch (e) {
+        config.logger.info('Extensions location cache not found, crawling directories')
+        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
+      }
+
+      const content = await fs.readFile(pathToLocationCache, 'utf8')
+
+      let cache
+
+      try {
+        cache = JSON.parse(content)[cacheEntryRootPath]
+      } catch (e) {
+        // file is corrupted, never mind and crawl the extensions
+      }
+
+      if (!cache) {
+        config.logger.info('Extensions location cache doesn\'t contain entry yet, crawling')
+        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
+      }
+
+      if (cache.rootDirectory !== config.rootDirectory) {
+        config.logger.info(`Extensions location cache ${pathToLocationCache} contains information with different rootDirectory, crawling`)
+        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
+      }
+
+      const stat = await fs.stat(cacheEntryRootPath)
+
+      if (stat.mtime.getTime() > cache.lastSync) {
+        config.logger.info(`Extensions location cache ${pathToLocationCache} contains older information, crawling`)
+        return fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js')
+      }
+
+      await Promise.all(cache.locations.map((l) => fs.stat(l)))
+
+      config.logger.info(`Extensions location cache contains up to date information, skipping crawling in ${config.rootDirectory}`)
+
+      // since the rootDirectory is dynamic (can be changed from options) we need to still
+      // crawl to see if we find new extensions if the rootDirectory was changed
+      const directories = fileUtils.walkSync(config.rootDirectory, 'jsreport.config.js', cacheEntryRootPath)
+      const result = directories.concat(cache.locations)
+
+      return result
+    },
+
+    async save (extensions) {
+      // we just want to store in cache the extensions found from the cache entry root path
+      // or in other words the ones from node_modules, we skip storing the extensions found
+      // in the rootDirectory
+      const directories = (
+        extensions
+          .map((e) => path.join(e.directory, 'jsreport.config.js'))
+          .filter((d) => d.startsWith(cacheEntryRootPath))
+      )
+
+      await fs.mkdir(config.tempCoreDirectory, { recursive: true })
+
+      try {
+        await fs.stat(pathToLocationCache)
+      } catch (e) {
+        await fs.writeFile(pathToLocationCache, JSON.stringify({}), 'utf8')
+      }
+
+      const content = await fs.readFile(pathToLocationCache, 'utf8')
+
+      let nodes = {}
+
+      try {
+        nodes = JSON.parse(content)
+      } catch (e) {
+        // file is corrupted, never mind and override all
+      }
+
+      nodes[cacheEntryRootPath] = {
+        rootDirectory: config.rootDirectory,
+        locations: directories,
+        lastSync: new Date().getTime()
+      }
+
+      config.logger.debug(`Writing extension locations cache to ${pathToLocationCache}`)
+
+      return fs.writeFile(pathToLocationCache, JSON.stringify(nodes), 'utf8')
+    }
+  }
+}

package/lib/main/extensions/sorter.js

@@ -1,10 +1,10 @@
-module.exports = (pa, pb) => {
-  // todo, sort better by dependencies
-  pa.dependencies = pa.dependencies || []
-  pb.dependencies = pb.dependencies || []
-
-  if (pa.dependencies.length > pb.dependencies.length) return 1
-  if (pa.dependencies.length < pb.dependencies.length) return -1
-
-  return 0
-}
+module.exports = (pa, pb) => {
+  // todo, sort better by dependencies
+  pa.dependencies = pa.dependencies || []
+  pb.dependencies = pb.dependencies || []
+
+  if (pa.dependencies.length > pb.dependencies.length) return 1
+  if (pa.dependencies.length < pb.dependencies.length) return -1
+
+  return 0
+}

package/lib/main/extensions/validateMinimalVersion.js

@@ -1,50 +1,50 @@
-const semver = require('semver')
-
-function validateMinimalVersion (baseExtension, extension) {
-  const generalErrorMsg = `${extension.name == null ? 'Anonymous extension' : `Extension "${extension.name}"`} is not compatible with "${baseExtension.name}" extension.`
-  const getExtensionLabel = () => extension.name == null ? 'anonymous extension' : `"${extension.name}"`
-
-  // this allows to validate pre-release versions too
-  const normalizeVersionResults = /^(\d+)\.(\d+)\.(\d+)(-.+)?$/.exec(baseExtension.version)
-
-  if (normalizeVersionResults == null) {
-    throw new Error(`Invalid format for version of "${baseExtension.name}" extension. Version found: "${baseExtension.version}"`)
-  }
-
-  let shouldValidateThatRequiresIsNotEmpty = true
-
-  if (
-    (extension.source === 'anonymous') ||
-    (extension.source === 'local' && extension.pkgVersion == null)
-  ) {
-    shouldValidateThatRequiresIsNotEmpty = false
-  }
-
-  if (shouldValidateThatRequiresIsNotEmpty && extension.requires == null) {
-    throw new Error(`${generalErrorMsg} Missing ".requires" information in ${getExtensionLabel(extension)} definition`)
-  }
-
-  const extensionRequires = extension.requires || {}
-  const baseExtensionRequireInExtension = extensionRequires[baseExtension.name]
-
-  if (baseExtensionRequireInExtension == null) {
-    return
-  }
-
-  const minimalVersionFormatRegExp = /^(x{1}|\d+)\.(x{1}|\d+)\.(x{1}|\d+)$/
-
-  if (!minimalVersionFormatRegExp.test(baseExtensionRequireInExtension)) {
-    throw new Error(`${generalErrorMsg} Invalid format for minimal version of "${baseExtension.name}" extension. Minimal version found in ${getExtensionLabel(extension)} definition: "${baseExtensionRequireInExtension}"`)
-  }
-
-  const baseVersion = `${normalizeVersionResults[1]}.${normalizeVersionResults[2]}.${normalizeVersionResults[3]}`
-  const targetSemVer = `>=${baseExtensionRequireInExtension}`
-
-  const isValid = semver.satisfies(baseVersion, targetSemVer)
-
-  if (!isValid) {
-    throw new Error(`${generalErrorMsg} Minimal version spec "${baseExtensionRequireInExtension}" found in ${getExtensionLabel(extension)} does not match with version "${baseExtension.version}" of "${baseExtension.name}"`)
-  }
-}
-
-module.exports = validateMinimalVersion
+const semver = require('semver')
+
+function validateMinimalVersion (baseExtension, extension) {
+  const generalErrorMsg = `${extension.name == null ? 'Anonymous extension' : `Extension "${extension.name}"`} is not compatible with "${baseExtension.name}" extension.`
+  const getExtensionLabel = () => extension.name == null ? 'anonymous extension' : `"${extension.name}"`
+
+  // this allows to validate pre-release versions too
+  const normalizeVersionResults = /^(\d+)\.(\d+)\.(\d+)(-.+)?$/.exec(baseExtension.version)
+
+  if (normalizeVersionResults == null) {
+    throw new Error(`Invalid format for version of "${baseExtension.name}" extension. Version found: "${baseExtension.version}"`)
+  }
+
+  let shouldValidateThatRequiresIsNotEmpty = true
+
+  if (
+    (extension.source === 'anonymous') ||
+    (extension.source === 'local' && extension.pkgVersion == null)
+  ) {
+    shouldValidateThatRequiresIsNotEmpty = false
+  }
+
+  if (shouldValidateThatRequiresIsNotEmpty && extension.requires == null) {
+    throw new Error(`${generalErrorMsg} Missing ".requires" information in ${getExtensionLabel(extension)} definition`)
+  }
+
+  const extensionRequires = extension.requires || {}
+  const baseExtensionRequireInExtension = extensionRequires[baseExtension.name]
+
+  if (baseExtensionRequireInExtension == null) {
+    return
+  }
+
+  const minimalVersionFormatRegExp = /^(x{1}|\d+)\.(x{1}|\d+)\.(x{1}|\d+)$/
+
+  if (!minimalVersionFormatRegExp.test(baseExtensionRequireInExtension)) {
+    throw new Error(`${generalErrorMsg} Invalid format for minimal version of "${baseExtension.name}" extension. Minimal version found in ${getExtensionLabel(extension)} definition: "${baseExtensionRequireInExtension}"`)
+  }
+
+  const baseVersion = `${normalizeVersionResults[1]}.${normalizeVersionResults[2]}.${normalizeVersionResults[3]}`
+  const targetSemVer = `>=${baseExtensionRequireInExtension}`
+
+  const isValid = semver.satisfies(baseVersion, targetSemVer)
+
+  if (!isValid) {
+    throw new Error(`${generalErrorMsg} Minimal version spec "${baseExtensionRequireInExtension}" found in ${getExtensionLabel(extension)} does not match with version "${baseExtension.version}" of "${baseExtension.name}"`)
+  }
+}
+
+module.exports = validateMinimalVersion

package/lib/main/folders/cascadeFolderRemove.js

@@ -1,25 +1,25 @@
-module.exports = (reporter) => {
-  reporter.documentStore.collection('folders').beforeRemoveListeners.add('folders', async (q, req) => {
-    const foldersToRemove = await reporter.documentStore.collection('folders').find(q, req)
-
-    for (const folder of foldersToRemove) {
-      for (const c of Object.keys(reporter.documentStore.collections)) {
-        const entities = await reporter.documentStore.collection(c).find({
-          folder: {
-            shortid: folder.shortid
-          }
-        }, req)
-
-        if (entities.length === 0) {
-          continue
-        }
-
-        for (const e of entities) {
-          await reporter.documentStore.collection(c).remove({
-            _id: e._id
-          }, req)
-        }
-      }
-    }
-  })
-}
+module.exports = (reporter) => {
+  reporter.documentStore.collection('folders').beforeRemoveListeners.add('folders', async (q, req) => {
+    const foldersToRemove = await reporter.documentStore.collection('folders').find(q, req)
+
+    for (const folder of foldersToRemove) {
+      for (const c of Object.keys(reporter.documentStore.collections)) {
+        const entities = await reporter.documentStore.collection(c).find({
+          folder: {
+            shortid: folder.shortid
+          }
+        }, req)
+
+        if (entities.length === 0) {
+          continue
+        }
+
+        for (const e of entities) {
+          await reporter.documentStore.collection(c).remove({
+            _id: e._id
+          }, req)
+        }
+      }
+    }
+  })
+}

package/lib/main/folders/getEntitiesInFolder.js

@@ -1,53 +1,53 @@
-
-module.exports = (reporter) => async function getEntitiesInFolder (folderShortId, recursive, req) {
-  if (folderShortId == null) {
-    throw new Error('Missing folder shortid param')
-  }
-
-  const entities = []
-  const lookup = []
-
-  for (const [entitySetName] of Object.entries(reporter.documentStore.model.entitySets)) {
-    lookup.push(reporter.documentStore.collection(entitySetName).find({
-      folder: {
-        shortid: folderShortId
-      }
-    }, req).then((results) => {
-      if (results.length === 0) {
-        return
-      }
-
-      if (entitySetName === 'folders') {
-        return Promise.all(results.map((folder) => {
-          entities.push({
-            entitySet: entitySetName,
-            entity: folder
-          })
-
-          if (recursive === true) {
-            return getEntitiesInFolder(folder.shortid, true, req)
-          }
-
-          return undefined
-        })).then((folderLookupResults) => {
-          folderLookupResults.forEach((childEntities) => {
-            if (childEntities) {
-              entities.push(...childEntities)
-            }
-          })
-        })
-      } else {
-        results.forEach((entity) => {
-          entities.push({
-            entitySet: entitySetName,
-            entity
-          })
-        })
-      }
-    }))
-  }
-
-  await Promise.all(lookup)
-
-  return entities
-}
+
+module.exports = (reporter) => async function getEntitiesInFolder (folderShortId, recursive, req) {
+  if (folderShortId == null) {
+    throw new Error('Missing folder shortid param')
+  }
+
+  const entities = []
+  const lookup = []
+
+  for (const [entitySetName] of Object.entries(reporter.documentStore.model.entitySets)) {
+    lookup.push(reporter.documentStore.collection(entitySetName).find({
+      folder: {
+        shortid: folderShortId
+      }
+    }, req).then((results) => {
+      if (results.length === 0) {
+        return
+      }
+
+      if (entitySetName === 'folders') {
+        return Promise.all(results.map((folder) => {
+          entities.push({
+            entitySet: entitySetName,
+            entity: folder
+          })
+
+          if (recursive === true) {
+            return getEntitiesInFolder(folder.shortid, true, req)
+          }
+
+          return undefined
+        })).then((folderLookupResults) => {
+          folderLookupResults.forEach((childEntities) => {
+            if (childEntities) {
+              entities.push(...childEntities)
+            }
+          })
+        })
+      } else {
+        results.forEach((entity) => {
+          entities.push({
+            entitySet: entitySetName,
+            entity
+          })
+        })
+      }
+    }))
+  }
+
+  await Promise.all(lookup)
+
+  return entities
+}