@davidwells/extract-deps 0.0.5 → 0.0.7

package/.claude/settings.local.json

@@ -1,7 +1,13 @@
 {
   "permissions": {
     "allow": [
-      "Bash(node:*)"
+      "Bash(node:*)",
+      "Bash(npm audit:*)",
+      "Bash(npm view:*)",
+      "Bash(npm pack:*)",
+      "Bash(tar:*)",
+      "Bash(npm install)",
+      "Bash(npm test)"
     ],
     "deny": [],
     "ask": []

package/examples/verify-basic.js

@@ -15,6 +15,8 @@ try {
   console.error(error.message)
 }
 
+console.log('foo')
+
 console.log('Verifying ESM fixture...')
 try {
   const graph = depGraph(esmFixture)

package/examples/verify-package-entries.js

@@ -0,0 +1,74 @@
+// Verify package.json entry points
+const path = require('path')
+const { getPackageEntryPoints, verifyPackageEntries } = require('../src/verify-package-json-entries')
+
+const pkgPath = path.resolve(__dirname, '../package.json')
+
+console.log('=== Extract All Package Entry Points ===\n')
+const entryPoints = getPackageEntryPoints(pkgPath)
+console.log(`Found ${entryPoints.length} entry points:\n`)
+entryPoints.forEach(ep => {
+  console.log(`  ${ep.field}: ${ep.path}`)
+})
+
+console.log('\n=== Verify Entries and Collect Dependencies ===\n')
+const results = verifyPackageEntries(pkgPath, {
+  collectDeps: true,    // Collect dependency paths
+  verifyGraph: false    // Skip verification (faster, for CI use case)
+})
+
+console.log('Results per entry point:\n')
+results.entryPoints.forEach(ep => {
+  const status = ep.valid ? '✓' : '✗'
+  console.log(`${status} ${ep.field}`)
+  if (ep.deps) {
+    console.log(`  ${ep.deps.length} dependencies`)
+  }
+  if (ep.error) {
+    console.log(`  Error: ${ep.error.message}`)
+  }
+  console.log()
+})
+
+console.log(`\n=== Summary ===`)
+console.log(`Total entry points: ${results.entryPoints.length}`)
+console.log(`Valid: ${results.entryPoints.filter(ep => ep.valid).length}`)
+console.log(`Errors: ${results.errors.length}`)
+console.log(`Total unique dependencies across all entry points: ${results.allDeps.size}`)
+
+if (results.allDeps.size > 0) {
+  console.log('\n=== All Dependencies (for git change tracking) ===')
+  const allDeps = Array.from(results.allDeps)
+  allDeps.forEach(dep => {
+    console.log(`  ${path.relative(process.cwd(), dep)}`)
+  })
+}
+
+console.log('\n=== Example: CI Use Case ===')
+console.log(`
+// In your CI script, you can use this to check if any deps changed:
+const { verifyPackageEntries } = require('extract-deps/verify-package-json-entries')
+const { execSync } = require('child_process')
+
+const pkgPath = './package.json'
+const results = verifyPackageEntries(pkgPath, { verifyGraph: false })
+
+// Get all unique dependency file paths
+const allDepPaths = Array.from(results.allDeps)
+
+// Check which ones changed in git
+const changedFiles = execSync('git diff --name-only HEAD~1 HEAD')
+  .toString()
+  .split('\\n')
+  .filter(Boolean)
+
+const changedDeps = allDepPaths.filter(dep => {
+  const relativePath = path.relative(process.cwd(), dep)
+  return changedFiles.includes(relativePath)
+})
+
+console.log(\`Changed dependencies: \${changedDeps.length}\`)
+if (changedDeps.length > 0) {
+  console.log('Need to rebuild/retest')
+}
+`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidwells/extract-deps",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Get imports and requires from a codebase without AST",
   "main": "src/index.js",
   "exports": {
@@ -22,7 +22,7 @@
     "release:major": "npm version major && npm publish"
   },
   "dependencies": {
-    "inspect-parameters-declaration": "^0.1.0"
+    "@dual-bundle/import-meta-resolve": "^4.2.1"
   },
   "devDependencies": {
     "typescript": "^5.7.3",

package/src/dep-graph.js

@@ -1,6 +1,8 @@
 // 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) {
@@ -12,6 +14,14 @@ function fsExistsSync(path) {
   }
 }
 
+function isFileSync(filePath) {
+  try {
+    return fs.statSync(filePath).isFile()
+  } catch (error) {
+    return false
+  }
+}
+
 /**
  * Resolve a relative import to an actual file path
  * @param {string} baseDir - Directory containing the importing file
@@ -21,10 +31,10 @@ function fsExistsSync(path) {
 function resolveImportPath(baseDir, importPath) {
   const possibleExtensions = ['.js', '.mjs', '.ts', '.json', '']
 
-  // Try direct file resolution
+  // Try direct file resolution (must be a file, not directory)
   for (const ext of possibleExtensions) {
     const testPath = path.resolve(baseDir, importPath + ext)
-    if (fsExistsSync(testPath)) {
+    if (isFileSync(testPath)) {
       return testPath
     }
   }
@@ -80,10 +90,12 @@ function verifyImportedValuesExist(dep, targetDeps, targetPath, sourcePath, erro
     // 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(
-          `Import not found: "${importedName}" is not exported from "${targetPath}".\n` +
-          `Import statement: ${dep.line}\n` +
-          `Importing from: ${sourcePath}\n` +
+          `\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) {
@@ -119,10 +131,19 @@ function verifyImportedValuesExist(dep, targetDeps, targetPath, sourcePath, erro
  * @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, graph = null, visited = new Set()) {
+function buildGraphRecursively(
+  filePath, 
+  errors, 
+  throwOnFirstError, 
+  verify, 
+  verifyNodeModules, 
+  graph = null, 
+  visited = new Set(),
+) {
   // Avoid infinite loops
   const normalizedPath = fs.realpathSync(filePath)
   if (visited.has(normalizedPath)) {
@@ -148,6 +169,17 @@ function buildGraphRecursively(filePath, errors, throwOnFirstError, verify, grap
     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) {
@@ -185,7 +217,34 @@ function buildGraphRecursively(filePath, errors, throwOnFirstError, verify, grap
     }
 
     // Recursively process the imported file
-    buildGraphRecursively(resolvedPath, errors, throwOnFirstError, verify, graph, visited)
+    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)
+      }
+    }
   }
 }
 
@@ -195,19 +254,27 @@ function buildGraphRecursively(filePath, errors, throwOnFirstError, verify, grap
  * @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, throwOnFirstError = false } = options
+  const { 
+    buildGraph = true, 
+    verifyGraph = true, 
+    verifyNodeModules = false, 
+    throwOnFirstError = false,
+  } = options
   const errors = []
   const graph = buildGraph ? new Map() : null
 
-  buildGraphRecursively(filePath, errors, throwOnFirstError, verifyGraph, graph)
+  buildGraphRecursively(filePath, errors, throwOnFirstError, verifyGraph, verifyNodeModules, graph)
 
   if (errors.length > 0) {
-    const errorMessage = errors.map((err, idx) => `Error ${idx + 1}:\n${err.message}`).join('\n\n')
-    throw new Error(`Found ${errors.length} validation error${errors.length === 1 ? '' : 's'}:\n\n${errorMessage}`)
+    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) {
@@ -263,10 +330,11 @@ function resolveDepPaths(filePath, options = {}) {
 
 if (require.main === module) {
   const entry = path.resolve(__dirname, '../tests/fixtures/cjs-deep-example/index.js')
-  const graph = depGraph(entry)
+  const graph = depGraph(entry, {
+    verifyNodeModules: false,
+    throwOnFirstError: true
+  })
   console.log('graph', graph)
-  const depPaths = Array.from(graph.values()).flat()
-  console.log('depPaths', depPaths)
   const depPathsProper = resolveDepPaths(entry)
   console.log('depPathsProper', depPathsProper)
 }

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(/^\./)