@davidwells/extract-deps 0.0.1 → 0.0.3

package/.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(node:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidwells/extract-deps",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Get imports and requires from a codebase without AST",
   "main": "src/index.js",
   "types": "types/index.d.ts",

package/src/get-cjs-exports.js

@@ -0,0 +1,351 @@
+// Extracts CommonJS module.exports and exports patterns from JavaScript code
+
+const { getNames } = require('./utils')
+
+// Matches: module.exports = ... or exports = module.exports = ...
+// https://regex101.com/r/example/cjs-1
+const MODULE_EXPORTS_ASSIGNMENT_REGEX = /^(?!\s*\/\/)(?!\s*\/\*)\s*(?:exports\s*=\s*)?module\.exports\s*=\s*(?!.*module\.exports\.)(.*?)$/gm
+
+// 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
+
+// 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
+
+function stripComments(code) {
+  let result = code
+
+  // Remove single-line comments but preserve newlines
+  result = result.replace(/\/\/.*$/gm, '')
+
+  // Remove multi-line comments but preserve line structure
+  result = result.replace(/\/\*[\s\S]*?\*\//g, (match) => {
+    // Replace comment with equivalent whitespace to preserve positions
+    return match.replace(/[^\n]/g, ' ')
+  })
+
+  return result
+}
+
+function getCjsExports(code) {
+  // Strip comments to prevent false positives from commented code
+  const sanitizedCode = stripComments(code)
+
+  const assignmentExports = getModuleExportsAssignment(code, sanitizedCode)
+  const modulePropertyExports = getModuleExportsProperty(code, sanitizedCode)
+  const propertyExports = getExportsProperty(code, sanitizedCode)
+  const objectAssignExports = getObjectAssignExports(code, sanitizedCode)
+
+  /*
+  console.log('assignmentExports', assignmentExports)
+  console.log('modulePropertyExports', modulePropertyExports)
+  console.log('propertyExports', propertyExports)
+  console.log('objectAssignExports', objectAssignExports)
+  /** */
+
+  const allExports = []
+    .concat(assignmentExports)
+    .concat(modulePropertyExports)
+    .concat(propertyExports)
+    .concat(objectAssignExports)
+
+  return allExports.sort((a, b) => a.index - b.index)
+}
+
+function extractExportDefName(exportValue) {
+  // Handle function declarations
+  if (exportValue.includes('function') && !exportValue.includes('=>')) {
+    const match = exportValue.match(/function\s+([\w$]+)/)
+    return match ? match[1] : 'anonymous'
+  }
+
+  // Handle class declarations
+  if (exportValue.includes('class')) {
+    const match = exportValue.match(/class\s+([\w$]+)/)
+    return match ? match[1] : 'anonymous'
+  }
+
+  // Handle arrow functions
+  if (exportValue.includes('=>')) {
+    return 'anonymous'
+  }
+
+  // Handle object/array literals
+  if (exportValue.startsWith('{') || exportValue.startsWith('[')) {
+    return 'literal'
+  }
+
+  // Handle simple values
+  return exportValue.trim()
+}
+
+function extractCompleteValue(text, startIndex) {
+  const firstChar = text[startIndex]
+
+  // For objects and arrays, balance braces/brackets
+  if (firstChar === '{' || firstChar === '[') {
+    const openChar = firstChar
+    const closeChar = firstChar === '{' ? '}' : ']'
+    let depth = 0
+    let i = startIndex
+
+    while (i < text.length) {
+      const char = text[i]
+      if (char === openChar) depth++
+      else if (char === closeChar) {
+        depth--
+        if (depth === 0) {
+          return text.substring(startIndex, i + 1)
+        }
+      }
+      i++
+    }
+    // If we couldn't find closing brace, return what we have
+    return text.substring(startIndex).split('\n')[0]
+  }
+
+  // For other values, extract to end of line
+  return text.substring(startIndex).split('\n')[0]
+}
+
+function getModuleExportsAssignment(originalText = '', sanitizedText = originalText) {
+  let exportStatements = []
+  var result
+
+  // Run regex on sanitized text to avoid matching commented code
+  while((result = MODULE_EXPORTS_ASSIGNMENT_REGEX.exec(sanitizedText)) !== null) {
+    const [ line, exportValue ] = result
+    const trimmedValue = exportValue.trim()
+
+    // Extract value from ORIGINAL text to preserve comments
+    // Since stripComments preserves positions, indices are the same
+    let completeValue = trimmedValue
+    if ((trimmedValue.startsWith('{') || trimmedValue.startsWith('[')) &&
+        !(trimmedValue.endsWith('}') || trimmedValue.endsWith(']'))) {
+      const valueStartIndex = result.index + line.indexOf(exportValue)
+      completeValue = extractCompleteValue(originalText, valueStartIndex).trim()
+    }
+
+    // Check if we have unbalanced parentheses (multiline function call)
+    const openParens = (trimmedValue.match(/\(/g) || []).length
+    const closeParens = (trimmedValue.match(/\)/g) || []).length
+    if (openParens > closeParens) {
+      const valueStartIndex = result.index + line.indexOf(exportValue)
+      let depth = 0
+      let i = valueStartIndex
+
+      while (i < originalText.length) {
+        const char = originalText[i]
+        if (char === '(') depth++
+        else if (char === ')') {
+          depth--
+          if (depth === 0) {
+            completeValue = originalText.substring(valueStartIndex, i + 1).trim()
+            break
+          }
+        }
+        i++
+      }
+    }
+
+    // Extract the same value from SANITIZED text for parsing definitions
+    let sanitizedCompleteValue = trimmedValue
+    if ((trimmedValue.startsWith('{') || trimmedValue.startsWith('[')) &&
+        !(trimmedValue.endsWith('}') || trimmedValue.endsWith(']'))) {
+      const valueStartIndex = result.index + line.indexOf(exportValue)
+      sanitizedCompleteValue = extractCompleteValue(sanitizedText, valueStartIndex).trim()
+    }
+    if (openParens > closeParens) {
+      const valueStartIndex = result.index + line.indexOf(exportValue)
+      let depth = 0
+      let i = valueStartIndex
+
+      while (i < sanitizedText.length) {
+        const char = sanitizedText[i]
+        if (char === '(') depth++
+        else if (char === ')') {
+          depth--
+          if (depth === 0) {
+            sanitizedCompleteValue = sanitizedText.substring(valueStartIndex, i + 1).trim()
+            break
+          }
+        }
+        i++
+      }
+    }
+
+    const exportDefName = extractExportDefName(sanitizedCompleteValue)
+
+    // Determine export type based on sanitized patterns
+    let exportType = 'default'
+
+    if (sanitizedCompleteValue.trim().startsWith('Object.assign')) {
+      exportType = 'object-assign'
+    }
+    else if (sanitizedCompleteValue.startsWith('{') && sanitizedCompleteValue.includes('...')) {
+      exportType = 'object-spread'
+    }
+
+    const exportStatement = {
+      line: line.trim(),
+      exportType,
+      exportName: '',
+      exportDefinitionName: exportDefName,
+      exportValue: completeValue,  // Use original value with comments
+      index: result.index,
+      isExport: true
+    }
+
+    // Parse object literals using SANITIZED value (no comments)
+    if (sanitizedCompleteValue.startsWith('{') && sanitizedCompleteValue.endsWith('}')) {
+      const definitions = getNames(sanitizedCompleteValue, 'definition')
+      if (definitions) {
+        exportStatement.definitions = definitions
+        exportStatement.keys = definitions.destructuredParameters.map(param => param.name)
+      }
+    }
+
+    exportStatements.push(exportStatement)
+  }
+
+  return exportStatements
+}
+
+function getModuleExportsProperty(originalText = '', sanitizedText = originalText) {
+  let exportStatements = []
+  var result
+
+  while((result = MODULE_EXPORTS_PROPERTY_REGEX.exec(sanitizedText)) !== null) {
+    const [ line, dotPropertyName, bracketPropertyName, propertyValue ] = result
+
+    // Use bracket notation property name if dot notation is undefined
+    const propertyName = dotPropertyName || bracketPropertyName
+
+    exportStatements.push({
+      line: line.trim(),
+      exportType: 'named',
+      exportName: propertyName.trim(),
+      exportValue: propertyValue.trim(),
+      index: result.index,
+      isExport: true
+    })
+  }
+
+  return exportStatements
+}
+
+function getExportsProperty(originalText = '', sanitizedText = originalText) {
+  let exportStatements = []
+  var result
+
+  while((result = EXPORTS_PROPERTY_REGEX.exec(sanitizedText)) !== null) {
+    const [ line, dotPropertyName, bracketPropertyName, propertyValue ] = result
+
+    // Use bracket notation property name if dot notation is undefined
+    const propertyName = dotPropertyName || bracketPropertyName
+
+    exportStatements.push({
+      line: line.trim(),
+      exportType: 'named',
+      exportName: propertyName.trim(),
+      exportValue: propertyValue.trim(),
+      index: result.index,
+      isExport: true
+    })
+  }
+
+  return exportStatements
+}
+
+function getObjectAssignExports(originalText = '', sanitizedText = originalText) {
+  let exportStatements = []
+
+  // Find all Object.assign calls with exports
+  const objectAssignPattern = /Object\.assign\s*\(\s*((?:module\.)?exports)\s*,/g
+  var result
+
+  while((result = objectAssignPattern.exec(sanitizedText)) !== null) {
+
+    const exportsTarget = result[1]
+
+    // Find the opening parenthesis of Object.assign and extract from ORIGINAL text
+    const openParenIndex = originalText.indexOf('(', result.index)
+
+    // Balance parentheses to find the complete Object.assign 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
+    }
+
+    const exportStatement = {
+      line: completeCall.split('\n')[0].trim(),
+      exportType: exportsTarget === 'module.exports' ? 'default' : 'object-assign',
+      exportName: 'Object.assign',
+      exportValue: completeCall,  // Original text with comments
+      index: result.index,
+      isExport: true
+    }
+
+    exportStatements.push(exportStatement)
+  }
+
+  return exportStatements
+}
+
+if(require.main === module) {
+  const code = `
+// module.exports assignment
+module.exports = function hello() {}
+
+// module.exports properties
+module.exports.hello = async event => {
+  console.log('lodash', lodash)
+  return {
+    statusCode: 200,
+    body: JSON.stringify(
+      {
+        message: 'Go Serverless v1.0! Your function executed successfully!',
+        input: event,
+      },
+      null,
+      2
+    ),
+  }
+}
+module.exports.world = function() { return 'world' }
+module.exports.MyClass = class MyClass {}
+
+// exports properties
+exports.foo = function() {}
+exports.bar = 'bar'
+  `
+
+  const exportsFound = getCjsExports(code)
+  exportsFound.forEach(item => console.log(item))
+}
+
+module.exports = {
+  getCjsExports,
+  getModuleExportsAssignment,
+  getModuleExportsProperty,
+  getExportsProperty,
+  getObjectAssignExports
+}

package/src/get-exports.js

@@ -180,12 +180,15 @@ function getAssertionExports(targetText = '') {
     const namesValues = (names || '').trim()
     // Remove leading newlines and whitespace from the line
     line = line.replace(/^\s+|\s+$/g, '')
-    
+
+    const definitions = getNames(namesValues)
+
     exportStatements.push({
       line,
       exportType: 'assertion',
       exportName: namesValues,
-      definitions: getNames(namesValues),
+      definitions,
+      keys: definitions.destructuredParameters.map(param => param.name),
       from,
       assertion: assertion.trim(),
       assertionType: keyword,
@@ -238,7 +241,7 @@ function parseExportsList(exportsList) {
     } else {
       exports.push({
         name: item,
-        alias: null
+        alias: undefined
       })
     }
   })

package/src/index.js

@@ -1,5 +1,7 @@
 const { getImports, getStaticImports, getDynamicImports } = require('./get-imports')
 const { getRequires, getStaticRequires, getDynamicRequires } = require('./get-requires')
+const { getCjsExports } = require('./get-cjs-exports')
+const { detectSyntax, hasESMSyntax, hasCJSSyntax } = require('./detect-syntax')
 const { 
   getExports, 
   getDefaultExports, 
@@ -21,7 +23,15 @@ function extractDeps(code, filePath = '') {
   // console.log('requires', requires)
   const foundExports = getExports(code)
   // console.log('exports', exports)
-  return { imports, requires, exports: foundExports }
+  const moduleExports = getCjsExports(code)
+  // console.log('moduleExports', moduleExports)
+  return { 
+    imports,
+    exports: foundExports,
+    // CJS
+    requires, 
+    moduleExports 
+  }
 }
 
 if (require.main === module) {
@@ -71,6 +81,10 @@ const { execSync, spawnSync } = require('child_process')
 
 module.exports = {
   extractDeps,
+  /* syntax detection */
+  hasESMSyntax,
+  hasCJSSyntax,
+  detectSyntax,
   /* Requires */
   getRequires,
   getDynamicRequires,

package/src/utils.js

@@ -11,27 +11,111 @@ function isRelativeImportWithQuotes(importLocation) {
     && importLocation.indexOf(' + ') === -1 // No string concatenation
 }
 
-function getNames(names) {
+function extractTopLevelKeys(objectLiteral) {
+  // Remove outer braces and trim
+  const content = objectLiteral.trim().replace(/^\{/, '').replace(/\}$/, '').trim()
+
+  if (!content) {
+    return []
+  }
+
+  const keys = []
+  let currentKey = ''
+  let depth = 0
+  let inString = false
+  let stringChar = null
+  let i = 0
+
+  while (i < content.length) {
+    const char = content[i]
+    const prevChar = i > 0 ? content[i - 1] : ''
+
+    // Handle string boundaries
+    if ((char === '"' || char === "'" || char === '`') && prevChar !== '\\') {
+      if (!inString) {
+        inString = true
+        stringChar = char
+      } else if (char === stringChar) {
+        inString = false
+        stringChar = null
+      }
+    }
+
+    if (!inString) {
+      // Track depth for nested objects/arrays
+      if (char === '{' || char === '[') {
+        depth++
+      } else if (char === '}' || char === ']') {
+        depth--
+      }
+
+      // At top level (depth 0), look for property separators
+      if (depth === 0) {
+        if (char === ':') {
+          // Found a key
+          const key = currentKey.trim()
+          if (key) {
+            keys.push({ name: key })
+          }
+          currentKey = ''
+
+          // Skip to next comma or end
+          let j = i + 1
+          depth = 0
+          while (j < content.length) {
+            const c = content[j]
+            if (c === '{' || c === '[') depth++
+            else if (c === '}' || c === ']') depth--
+            else if (c === ',' && depth === 0) {
+              i = j
+              break
+            }
+            j++
+          }
+          if (j === content.length) {
+            i = j - 1
+          }
+        } else if (char === ',') {
+          currentKey = ''
+        } else if (char !== ' ' && char !== '\n' && char !== '\t') {
+          currentKey += char
+        }
+      }
+    }
+
+    i++
+  }
+
+  return keys
+}
+
+function getNames(names, aliasKey = 'alias') {
   // console.log('names', names)
   // Safety check for undefined or null names
   if (!names || names.trim() === '') {
     return null
   }
   const results = inspectParameters(names).map((item) => {
+    /*
+    console.log('item', item)
+    /** */
     item.name = item.parameter
     if (item.destructuredParameters && item.destructuredParameters.length > 0) {
       item.destructuredParameters = item.destructuredParameters.map((details) => {
+        /*
+        console.log('details', details)
+        /** */
         if (details.parameter.indexOf(':') > -1) {
-          const [ name, alias ] = details.parameter.replace(/^{/, '').replace(/}$/, '').split(':')
+          const [ name, alias ] = details['declaration'].replace(/^{/, '').replace(/}$/, '').split(':')
           details.name = name.trim()
-          details.alias = alias.trim()
+          details[aliasKey]= alias.trim()
           delete details.parameter
           return details
         }
         if (details.declaration.indexOf(' as ') > -1) {
           const [ parameter, alias ] = details.declaration.split(' as ')
           details.name = parameter.trim()
-          details.alias = alias.trim()
+          details[aliasKey] = alias.trim()
           delete details.parameter
           return details
         }
@@ -51,9 +135,23 @@ function getNames(names) {
 
     return item
   })
-  
+
   // Return the first (and only) result instead of the array
-  return results.length > 0 ? results[0] : null
+  const result = results.length > 0 ? results[0] : null
+
+  // If we have an object with empty destructuredParameters, try to extract top-level keys
+  if (result &&
+      result.expectsDestructuring &&
+      result.destructuredParameters &&
+      result.destructuredParameters.length === 0 &&
+      names.trim().startsWith('{')) {
+    const topLevelKeys = extractTopLevelKeys(names)
+    if (topLevelKeys.length > 0) {
+      result.destructuredParameters = topLevelKeys
+    }
+  }
+
+  return result
 }