@davidwells/extract-deps 0.0.4 → 0.0.6

package/src/dep-graph.js

@@ -0,0 +1,337 @@
+// Build dependency graph and optionally verify imports
+const path = require('path')
+const fs = require('fs')
+const { pathToFileURL, fileURLToPath } = require('url')
+const { resolve: resolveImport } = require('@dual-bundle/import-meta-resolve')
+const { extractDeps } = require('./index')
+
+function fsExistsSync(path) {
+  try {
+    fs.accessSync(path, fs.constants.F_OK)
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+/**
+ * Resolve a relative import to an actual file path
+ * @param {string} baseDir - Directory containing the importing file
+ * @param {string} importPath - The relative import path
+ * @returns {string|null} - Resolved file path or null if not found
+ */
+function resolveImportPath(baseDir, importPath) {
+  const possibleExtensions = ['.js', '.mjs', '.ts', '.json', '']
+
+  // Try direct file resolution
+  for (const ext of possibleExtensions) {
+    const testPath = path.resolve(baseDir, importPath + ext)
+    if (fsExistsSync(testPath)) {
+      return testPath
+    }
+  }
+
+  // Try directory with index file
+  const indexExtensions = ['/index.js', '/index.mjs', '/index.ts']
+  for (const indexExt of indexExtensions) {
+    const testPath = path.resolve(baseDir, importPath + indexExt)
+    if (fsExistsSync(testPath)) {
+      return testPath
+    }
+  }
+
+  return null
+}
+
+/**
+ * Verify that imported values are exported from a file
+ * @param {object} dep - Dependency object with import info
+ * @param {object} targetDeps - Extracted deps from the target file
+ * @param {string} targetPath - Path to the target file
+ * @param {string} sourcePath - Path to the file doing the importing
+ * @param {Array<Error>} errors - Array to collect errors
+ * @param {boolean} throwOnFirstError - Whether to throw immediately on first error
+ */
+function verifyImportedValuesExist(dep, targetDeps, targetPath, sourcePath, errors, throwOnFirstError) {
+  // Check if this is a destructured import
+  if (dep.definitions && dep.definitions.expectsDestructuring && dep.definitions.destructuredParameters) {
+    const importedNames = dep.definitions.destructuredParameters.map(p => p.name.replace(/,$/, ''))
+
+    // Check CommonJS exports
+    const exportedNames = new Set()
+    if (targetDeps.moduleExports && targetDeps.moduleExports.length > 0) {
+      for (const exp of targetDeps.moduleExports) {
+        if (exp.exportType === 'named') {
+          exportedNames.add(exp.exportName)
+        } else if (exp.exportType === 'default' && exp.keys) {
+          exp.keys.forEach(key => exportedNames.add(key))
+        }
+      }
+    }
+
+    // Check ESM exports
+    if (targetDeps.exports && targetDeps.exports.length > 0) {
+      for (const exp of targetDeps.exports) {
+        const exportedName = exp.exportAlias || exp.exportName
+        if (exportedName) {
+          exportedNames.add(exportedName)
+        }
+      }
+    }
+
+    // Verify each imported name is exported
+    for (const importedName of importedNames) {
+      if (!exportedNames.has(importedName)) {
+        const type = (dep.line.indexOf('import') !== -1 ? 'Import' : 'Require')
+        const error = new Error(
+          `\n${type} "${importedName}" not found from statement:\n` +
+          `${dep.line}\n` +
+          `in "${sourcePath} file.\n\n` +
+          `The "${importedName}" value is not exported from file "${targetPath}".\n\n` +
+          `Available exports: ${Array.from(exportedNames).join(', ') || 'none'}`
+        )
+        if (throwOnFirstError) {
+          throw error
+        }
+        errors.push(error)
+      }
+    }
+  }
+  // For non-destructured imports, just verify there's a default export
+  else {
+    const hasDefaultExport =
+      (targetDeps.moduleExports && targetDeps.moduleExports.length > 0) ||
+      (targetDeps.exports && targetDeps.exports.some(exp => exp.exportType === 'default'))
+
+    if (!hasDefaultExport) {
+      const error = new Error(
+        `Import not found: "${targetPath}" does not have a default export.\n` +
+        `Import statement: ${dep.line}\n` +
+        `Importing from: ${sourcePath}`
+      )
+      if (throwOnFirstError) {
+        throw error
+      }
+      errors.push(error)
+    }
+  }
+}
+
+/**
+ * Recursively build dependency graph and optionally validate imports
+ * @param {string} filePath - File to process
+ * @param {Array<Error>} errors - Array to collect errors
+ * @param {boolean} throwOnFirstError - Whether to throw immediately on first error
+ * @param {boolean} verify - Whether to verify imports/exports
+ * @param {boolean} verifyNodeModules - Whether to verify node_modules can be resolved
+ * @param {Map<string, string[]>|null} graph - Optional map to collect dependency graph
+ * @param {Set} visited - Set of already-visited file paths to avoid cycles
+ */
+function buildGraphRecursively(
+  filePath, 
+  errors, 
+  throwOnFirstError, 
+  verify, 
+  verifyNodeModules, 
+  graph = null, 
+  visited = new Set(),
+) {
+  // Avoid infinite loops
+  const normalizedPath = fs.realpathSync(filePath)
+  if (visited.has(normalizedPath)) {
+    return
+  }
+  visited.add(normalizedPath)
+
+  // Initialize graph entry for this file if building graph
+  if (graph !== null && !graph.has(normalizedPath)) {
+    graph.set(normalizedPath, [])
+  }
+
+  // Read and extract deps from this file
+  const content = fs.readFileSync(filePath, 'utf8')
+  const deps = extractDeps(content)
+
+  // Collect all relative dependencies
+  const relativeDeps = []
+  if (deps.requires && deps.requires.length > 0) {
+    relativeDeps.push(...deps.requires.filter(req => req.isRelative))
+  }
+  if (deps.imports && deps.imports.length > 0) {
+    relativeDeps.push(...deps.imports.filter(imp => imp.isRelative))
+  }
+
+  // Collect all non-relative dependencies (node_modules)
+  const nodeModuleDeps = []
+  if (verifyNodeModules) {
+    if (deps.requires && deps.requires.length > 0) {
+      nodeModuleDeps.push(...deps.requires.filter(req => !req.isRelative))
+    }
+    if (deps.imports && deps.imports.length > 0) {
+      nodeModuleDeps.push(...deps.imports.filter(imp => !imp.isRelative))
+    }
+  }
+
+  // Process each relative dependency
+  const fileDir = path.dirname(filePath)
+  for (const dep of relativeDeps) {
+    const { from, line } = dep
+
+    // Resolve the import path
+    const resolvedPath = resolveImportPath(fileDir, from)
+
+    if (!resolvedPath) {
+      const error = new Error(
+        `"${line}" could not be resolved in ${filePath}\n\n` +
+        `Fix by ensuring "${path.resolve(fileDir, from)}" exists and is valid.`
+      )
+      if (throwOnFirstError) {
+        throw error
+      }
+      errors.push(error)
+      continue
+    }
+
+    // Add edge to graph if building
+    if (graph !== null) {
+      const normalizedResolvedPath = fs.realpathSync(resolvedPath)
+      graph.get(normalizedPath).push(normalizedResolvedPath)
+    }
+
+    // Verify imports if verification is enabled
+    if (verify) {
+      // Extract deps from the imported file
+      const targetContent = fs.readFileSync(resolvedPath, 'utf8')
+      const targetDeps = extractDeps(targetContent)
+
+      // Verify the imported values are exported
+      verifyImportedValuesExist(dep, targetDeps, resolvedPath, filePath, errors, throwOnFirstError)
+    }
+
+    // Recursively process the imported file
+    buildGraphRecursively(resolvedPath, errors, throwOnFirstError, verify, verifyNodeModules, graph, visited)
+  }
+
+  // Verify node_modules dependencies if enabled
+  if (verifyNodeModules && nodeModuleDeps.length > 0) {
+    const parentURL = pathToFileURL(filePath).href
+
+    for (const dep of nodeModuleDeps) {
+      const { from, line } = dep
+
+      try {
+        // Try to resolve the module using Node's resolution algorithm
+        const resolved = resolveImport(from, parentURL)
+        //console.log('resolved', resolved)
+        // If we get here, the module resolved successfully
+      } catch (error) {
+        const err = new Error(
+          `"${line}" could not be resolved in ${filePath}\n\n` +
+          `The package "${from}" is not installed or cannot be found.\n` +
+          `Run "npm install ${from}" to fix this issue.\n\n` +
+          `Resolution error: ${error.message}`
+        )
+        if (throwOnFirstError) {
+          throw err
+        }
+        errors.push(err)
+      }
+    }
+  }
+}
+
+/**
+ * Build dependency graph for a file and its dependencies
+ * @param {string} filePath - File to analyze
+ * @param {object} options - Options
+ * @param {boolean} [options.buildGraph] - If true, build and return dependency graph. Default: true
+ * @param {boolean} [options.verifyGraph] - If true, verify imports/exports. Default: true
+ * @param {boolean} [options.verifyNodeModules] - If true, verify node_modules packages can be resolved. Default: false
+ * @param {boolean} [options.throwOnFirstError] - If true, throw immediately on first error. Default: false
+ * @returns {Map<string, string[]>|undefined} - Dependency graph where keys are file paths and values are arrays of dependency paths. Returns undefined if buildGraph is false.
+ */
+function depGraph(filePath, options = {}) {
+  const { 
+    buildGraph = true, 
+    verifyGraph = true, 
+    verifyNodeModules = false, 
+    throwOnFirstError = false,
+  } = options
+  const errors = []
+  const graph = buildGraph ? new Map() : null
+
+  buildGraphRecursively(filePath, errors, throwOnFirstError, verifyGraph, verifyNodeModules, graph)
+
+  if (errors.length > 0) {
+    const errorMessage = errors.map((err, idx) => `Dep graph error:\n ${err.message}`).join('\n')
+    throw new Error(
+      `Found ${errors.length} validation error${errors.length === 1 ? '' : 's'}:\n\n${errorMessage}`
+    )
+  }
+
+  if (buildGraph) {
+    return graph
+  }
+}
+
+
+/**
+ * Get all dependency file paths in build order (dependencies first), deduplicated
+ * @param {string} filePath - Entry file path
+ * @param {object} options - Options to pass to depGraph
+ * @returns {string[]} - Array of unique dependency file paths in topological order
+ */
+function resolveDepPaths(filePath, options = {}) {
+  const graph = depGraph(filePath, options)
+
+  // Calculate in-degree (number of dependencies) for each file
+  const inDegree = new Map()
+  for (const [file, deps] of graph) {
+    inDegree.set(file, deps.length)
+  }
+
+  // Queue of files with no dependencies (can be processed first)
+  const queue = []
+  for (const [file, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(file)
+    }
+  }
+
+  const buildOrder = []
+
+  while (queue.length > 0) {
+    const file = queue.shift()
+    buildOrder.push(file)
+
+    // Find all files that depend on this file and decrement their in-degree
+    for (const [dependent, deps] of graph) {
+      if (deps.includes(file)) {
+        const newDegree = inDegree.get(dependent) - 1
+        inDegree.set(dependent, newDegree)
+        if (newDegree === 0) {
+          queue.push(dependent)
+        }
+      }
+    }
+  }
+
+  return buildOrder
+}
+
+
+if (require.main === module) {
+  const entry = path.resolve(__dirname, '../tests/fixtures/cjs-deep-example/index.js')
+  const graph = depGraph(entry, {
+    verifyNodeModules: false,
+    throwOnFirstError: true
+  })
+  console.log('graph', graph)
+  const depPathsProper = resolveDepPaths(entry)
+  console.log('depPathsProper', depPathsProper)
+}
+
+module.exports = {
+  depGraph,
+  resolveDepPaths
+}

package/src/get-cjs-exports.js

@@ -8,17 +8,22 @@ const MODULE_EXPORTS_ASSIGNMENT_REGEX = /^(?!\s*\/\/)(?!\s*\/\*)\s*(?:exports\s*
 
 // Matches: module.exports.propertyName = ... or module.exports['propertyName'] = ...
 // https://regex101.com/r/example/cjs-2
-const MODULE_EXPORTS_PROPERTY_REGEX = /module\.exports(?:\.([\w$]+)|\[['"]([^'"]+)['"]\])\s*=\s*(.+?)(?=\s*(?:module\.exports|exports\.|\/\/|\/\*|$))/gs
+const MODULE_EXPORTS_PROPERTY_REGEX = /module\.exports(?:\.([\w$]+)|\[['"]([^'"]+)['"]\])\s*=\s*(.+?)(?=\n\s*\n|(?:module\.exports|exports\.|Object\.defineProperty|\/\/|\/\*|$))/gs
 
 // Matches: exports.propertyName = ... or exports['propertyName'] = ...
 // https://regex101.com/r/example/cjs-3
-const EXPORTS_PROPERTY_REGEX = /(?<!module\.)exports(?:\.([\w$]+)|\[['"]([^'"]+)['"]\])\s*=\s*(.+?)(?=\s*(?:module\.exports|exports\.|\/\/|\/\*|$))/gs
+const EXPORTS_PROPERTY_REGEX = /(?<!module\.)exports(?:\.([\w$]+)|\[['"]([^'"]+)['"]\])\s*=\s*(.+?)(?=\n\s*\n|(?:module\.exports|exports\.|Object\.defineProperty|\/\/|\/\*|$))/gs
 
 function stripComments(code) {
   let result = code
 
-  // Remove single-line comments but preserve newlines
-  result = result.replace(/\/\/.*$/gm, '')
+  // Remove single-line comments but preserve string positions
+  // This is critical: we must preserve the exact length of the string so that
+  // indices found in sanitized text match indices in original text
+  result = result.replace(/\/\/(.*)$/gm, (match, commentText) => {
+    // Replace // and comment text with spaces (same length as original)
+    return '  ' + ' '.repeat(commentText.length)
+  })
 
   // Remove multi-line comments but preserve line structure
   result = result.replace(/\/\*[\s\S]*?\*\//g, (match) => {
@@ -36,13 +41,22 @@ function getCjsExports(code) {
   const assignmentExports = getModuleExportsAssignment(code, sanitizedCode)
   const modulePropertyExports = getModuleExportsProperty(code, sanitizedCode)
   const propertyExports = getExportsProperty(code, sanitizedCode)
-  const objectAssignExports = getObjectAssignExports(code, sanitizedCode)
+  
+  // Quick pre-checks to avoid expensive regex operations when not needed
+  const objectAssignExports = sanitizedCode.includes('Object.assign')
+    ? getObjectAssignExports(code, sanitizedCode)
+    : []
+  
+  const definePropertyExports = sanitizedCode.includes('Object.defineProperty')
+    ? getDefinePropertyExports(code, sanitizedCode)
+    : []
 
   /*
   console.log('assignmentExports', assignmentExports)
   console.log('modulePropertyExports', modulePropertyExports)
   console.log('propertyExports', propertyExports)
   console.log('objectAssignExports', objectAssignExports)
+  console.log('definePropertyExports', definePropertyExports)
   /** */
 
   const allExports = []
@@ -50,6 +64,7 @@ function getCjsExports(code) {
     .concat(modulePropertyExports)
     .concat(propertyExports)
     .concat(objectAssignExports)
+    .concat(definePropertyExports)
 
   return allExports.sort((a, b) => a.index - b.index)
 }
@@ -283,7 +298,81 @@ function getObjectAssignExports(originalText = '', sanitizedText = originalText)
   return exportStatements
 }
 
-if(require.main === module) {
+function getDefinePropertyExports(originalText = '', sanitizedText = originalText) {
+  let exportStatements = []
+
+  // Find all Object.defineProperty calls with module or exports
+  // Matches: Object.defineProperty(module, 'exports', ...) or Object.defineProperty(exports, 'propertyName', ...)
+  const definePropertyPattern = /Object\.defineProperty\s*\(\s*(module|exports)\s*,\s*['"]([^'"]+)['"]/g
+  var result
+
+  while((result = definePropertyPattern.exec(sanitizedText)) !== null) {
+    const target = result[1]
+    const propertyName = result[2]
+
+    // Find the opening parenthesis of Object.defineProperty
+    const openParenIndex = result.index + result[0].indexOf('(')
+
+    // Balance parentheses to find the complete Object.defineProperty call
+    let depth = 0
+    let i = openParenIndex
+    let completeCall = ''
+
+    while (i < originalText.length) {
+      const char = originalText[i]
+      if (char === '(') depth++
+      else if (char === ')') {
+        depth--
+        if (depth === 0) {
+          completeCall = originalText.substring(result.index, i + 1)
+          break
+        }
+      }
+      i++
+    }
+
+    if (!completeCall) {
+      continue
+    }
+
+    // Try to extract the getter function if present
+    // Matches: get: functionName or get: () => ... or get() { ... }
+    const getterMatch = completeCall.match(/get\s*:\s*(\w+)|get\s*:\s*(\([^)]*\)\s*=>)|get\s*\(/)
+    let getterValue = ''
+    if (getterMatch) {
+      if (getterMatch[1]) {
+        // Named function: get: functionName
+        getterValue = getterMatch[1]
+      } else if (getterMatch[2]) {
+        // Arrow function: get: () =>
+        getterValue = 'arrow function'
+      } else {
+        // Method: get() { ... }
+        getterValue = 'getter method'
+      }
+    }
+
+    // Determine if this is a module.exports or property export
+    const isModuleExports = target === 'module' && propertyName === 'exports'
+
+    const exportStatement = {
+      line: completeCall.trim(),
+      exportType: isModuleExports ? 'default' : 'named',
+      exportName: isModuleExports ? '' : propertyName,
+      exportValue: completeCall,  // Original text with comments
+      exportDefinitionName: getterValue || propertyName,
+      index: result.index,
+      isExport: true,
+      isDefineProperty: true
+    }
+
+    exportStatements.push(exportStatement)
+  }
+
+  return exportStatements
+}
+
+if (require.main === module) {
   const code = `
 // module.exports assignment
 module.exports = function hello() {}
@@ -309,6 +398,21 @@ module.exports.MyClass = class MyClass {}
 // exports properties
 exports.foo = function() {}
 exports.bar = 'bar'
+
+// Object.defineProperty exports
+function assembleStyles() {
+  return { color: 'red' }
+}
+
+Object.defineProperty(module, 'exports', {
+  enumerable: true,
+  get: assembleStyles
+})
+
+Object.defineProperty(exports, 'myProperty', {
+  enumerable: true,
+  get: () => 'value'
+})
   `
 
   const exportsFound = getCjsExports(code)
@@ -320,5 +424,6 @@ module.exports = {
   getModuleExportsAssignment,
   getModuleExportsProperty,
   getExportsProperty,
-  getObjectAssignExports
+  getObjectAssignExports,
+  getDefinePropertyExports
 }

package/src/get-imports.js

@@ -52,6 +52,7 @@ function getTypeImports(targetText = '') {
       importName: (importName || '').trim(),
       index: result.index,
       isImport: true,
+      isTypeImport: true,
       isRelative: isRelativeImport(importPath)
     })
   }

package/src/utils.js

@@ -1,4 +1,4 @@
-const { inspectParameters, getParametersNames } = require('inspect-parameters-declaration')
+const { inspectParameters, getParametersNames } = require('./vendor/inspect-parameters-declaration')
 
 function isRelativeImport(importLocation) {
   return !!importLocation.match(/^\./)