@davidwells/extract-deps 0.0.1 → 0.0.3

package/tests/get-cjs-exports.test.js

@@ -0,0 +1,539 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const {
+  getCjsExports,
+  getModuleExportsAssignment,
+  getModuleExportsProperty,
+  getExportsProperty
+} = require('../src/get-cjs-exports.js')
+
+test('should extract module.exports = {} assignments', () => {
+  const code = `
+module.exports = function hello() {}
+module.exports = class MyClass {}
+module.exports = { foo: 'bar' }
+module.exports = [1, 2, 3]
+module.exports = 'hello'
+module.exports = 42
+module.exports = () => {}
+  `
+
+  const foundExports = getModuleExportsAssignment(code)
+  // console.log('foundExports', foundExports)
+
+  assert.ok(foundExports.length === 7, 'Should find 7 module.exports assignments')
+
+  // Check function export
+  const functionExport = foundExports.find(exp => exp.exportDefinitionName === 'hello')
+  assert.ok(functionExport, 'Should find function export')
+  assert.equal(functionExport.exportType, 'default')
+  assert.equal(functionExport.exportValue, 'function hello() {}')
+
+  // Check class export
+  const classExport = foundExports.find(exp => exp.exportDefinitionName === 'MyClass')
+  assert.ok(classExport, 'Should find class export')
+  assert.equal(classExport.exportType, 'default')
+  assert.equal(classExport.exportValue, 'class MyClass {}')
+
+  // Check object literal
+  const objectExport = foundExports.find(exp => exp.exportDefinitionName === 'literal')
+  assert.ok(objectExport, 'Should find object literal export')
+  assert.equal(objectExport.exportValue, "{ foo: 'bar' }")
+
+  // Check array literal
+  const arrayExport = foundExports.find(exp => exp.exportValue === '[1, 2, 3]')
+  assert.ok(arrayExport, 'Should find array literal export')
+  assert.equal(arrayExport.exportName, '')
+
+  // Check string literal
+  const stringExport = foundExports.find(exp => exp.exportValue === "'hello'")
+  assert.ok(stringExport, 'Should find string literal export')
+  assert.equal(stringExport.exportName, "")
+
+  // Check number literal
+  const numberExport = foundExports.find(exp => exp.exportValue === '42')
+  assert.ok(numberExport, 'Should find number literal export')
+  assert.equal(numberExport.exportName, '')
+
+  // Check arrow function
+  const arrowExport = foundExports.find(exp => exp.exportValue === '() => {}')
+  assert.ok(arrowExport, 'Should find arrow function export')
+  assert.equal(arrowExport.exportName, '')
+
+  foundExports.forEach(exp => {
+    assert.equal(exp.exportType, 'default')
+    assert.ok(exp.isExport)
+  })
+})
+
+test('should extract module.exports.property assignments', () => {
+  const code = `
+module.exports.hello = async event => {
+  console.log('lodash', lodash)
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: 'Hello' })
+  }
+}
+module.exports.world = function() { return 'world' }
+module.exports.MyClass = class MyClass {}
+module.exports.config = { foo: 'bar' }
+module.exports.items = [1, 2, 3]
+  `
+
+  const foundExports = getModuleExportsProperty(code)
+
+  assert.ok(foundExports.length === 5, 'Should find 5 module.exports property assignments')
+
+  const exportNames = foundExports.map(exp => exp.exportName)
+  assert.ok(exportNames.includes('hello'), 'Should find hello export')
+  assert.ok(exportNames.includes('world'), 'Should find world export')
+  assert.ok(exportNames.includes('MyClass'), 'Should find MyClass export')
+  assert.ok(exportNames.includes('config'), 'Should find config export')
+  assert.ok(exportNames.includes('items'), 'Should find items export')
+
+  foundExports.forEach(exp => {
+    assert.equal(exp.exportType, 'named')
+    assert.ok(exp.isExport)
+  })
+})
+
+test('should extract exports.property assignments', () => {
+  const code = `
+exports.hello = function() {}
+exports.world = () => {}
+exports.MyClass = class MyClass {}
+exports.config = { foo: 'bar' }
+exports.items = [1, 2, 3]
+exports.name = 'test'
+  `
+
+  const foundExports = getExportsProperty(code)
+
+  assert.ok(foundExports.length === 6, 'Should find 6 exports property assignments')
+
+  const exportNames = foundExports.map(exp => exp.exportName)
+  assert.ok(exportNames.includes('hello'), 'Should find hello export')
+  assert.ok(exportNames.includes('world'), 'Should find world export')
+  assert.ok(exportNames.includes('MyClass'), 'Should find MyClass export')
+  assert.ok(exportNames.includes('config'), 'Should find config export')
+  assert.ok(exportNames.includes('items'), 'Should find items export')
+  assert.ok(exportNames.includes('name'), 'Should find name export')
+
+  foundExports.forEach(exp => {
+    assert.equal(exp.exportType, 'named')
+    assert.ok(exp.isExport)
+  })
+})
+
+test('should combine all CJS export types in getCjsExports', () => {
+  const code = `
+// module.exports assignment
+module.exports = {
+  hello: function() {},
+  world: 'test'
+}
+
+// module.exports properties
+module.exports.foo = function() {}
+module.exports.bar = 'bar'
+
+// exports properties
+exports.baz = function() {}
+exports.qux = 'qux'
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 5, 'Should find 5 total exports')
+
+  // Check sorting by index
+  for (let i = 1; i < foundExports.length; i++) {
+    assert.ok(foundExports[i].index >= foundExports[i-1].index, 'Exports should be sorted by index')
+  }
+})
+
+test('should handle empty code', () => {
+  const foundExports = getCjsExports('')
+
+  assert.ok(foundExports.length === 0, 'Should return empty array for empty code')
+})
+
+test('should handle code with no exports', () => {
+  const code = `
+function myFunction() {}
+const myVariable = 'value'
+const hello = require('./hello')
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 0, 'Should return empty array for code with no exports')
+})
+
+test('should handle complex arrow functions', () => {
+  const code = `
+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
+    ),
+  }
+}
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 export')
+  assert.equal(foundExports[0].exportName, 'hello', 'Should find hello export')
+  assert.equal(foundExports[0].exportType, 'named', 'Should be named type')
+})
+
+test('should handle module.exports with object shorthand', () => {
+  const code = `
+const hello = function() {}
+const world = 'test'
+module.exports = { hello, world }
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 module.exports assignment')
+  assert.equal(foundExports[0].exportType, 'default')
+  assert.equal(foundExports[0].exportName, '')
+  assert.equal(foundExports[0].exportValue, '{ hello, world }')
+
+  // Check definitions
+  assert.ok(foundExports[0].definitions, 'Should have definitions')
+  assert.ok(foundExports[0].definitions.expectsDestructuring, 'Should expect destructuring')
+  assert.equal(foundExports[0].definitions.destructuredParameters.length, 2, 'Should have 2 properties')
+  assert.equal(foundExports[0].definitions.destructuredParameters[0].name, 'hello')
+  assert.equal(foundExports[0].definitions.destructuredParameters[1].name, 'world')
+})
+
+test('should handle SINGLELINE module.exports with object property references', () => {
+  const code = `
+const barRef = function() { return 'bar' }
+const fooValue = 'foo'
+module.exports = { bar: barRef, foo: fooValue }
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 module.exports assignment')
+  assert.equal(foundExports[0].exportType, 'default')
+  assert.equal(foundExports[0].exportName, '')
+  assert.ok(foundExports[0].exportValue.includes('bar: barRef'), 'Should include bar property')
+  assert.ok(foundExports[0].exportValue.includes('foo: fooValue'), 'Should include foo property')
+
+  // Check definitions
+  assert.ok(foundExports[0].definitions, 'Should have definitions')
+  assert.ok(foundExports[0].definitions.expectsDestructuring, 'Should expect destructuring')
+  assert.equal(foundExports[0].definitions.destructuredParameters.length, 2, 'Should have 2 properties')
+
+  // Check bar property
+  const barParam = foundExports[0].definitions.destructuredParameters[0]
+  assert.equal(barParam.name, 'bar', 'First property name should be bar')
+  assert.equal(barParam.definition, 'barRef', 'First property alias should be barRef')
+
+  // Check foo property
+  const fooParam = foundExports[0].definitions.destructuredParameters[1]
+  assert.equal(fooParam.name, 'foo', 'Second property name should be foo')
+  assert.equal(fooParam.definition, 'fooValue', 'Second property alias should be fooValue')
+})
+
+test('should handle MULTILINE module.exports with object property references', () => {
+  const code = `
+const barRef = function() { return 'bar' }
+const fooValue = 'foo'
+module.exports = {
+  bar: barRef,
+  foo: fooValue
+}
+`
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 module.exports assignment')
+  assert.equal(foundExports[0].exportType, 'default')
+  assert.equal(foundExports[0].exportName, '')
+  assert.ok(foundExports[0].exportValue.includes('bar: barRef'), 'Should include bar property')
+  assert.ok(foundExports[0].exportValue.includes('foo: fooValue'), 'Should include foo property')
+
+  // Check definitions
+  assert.ok(foundExports[0].definitions, 'Should have definitions')
+  assert.ok(foundExports[0].definitions.expectsDestructuring, 'Should expect destructuring')
+  assert.equal(foundExports[0].definitions.destructuredParameters.length, 2, 'Should have 2 properties')
+
+  // Check bar property
+  const barParam = foundExports[0].definitions.destructuredParameters[0]
+  assert.equal(barParam.name, 'bar', 'First property name should be bar')
+  assert.equal(barParam.definition, 'barRef', 'First property alias should be barRef')
+
+  // Check foo property
+  const fooParam = foundExports[0].definitions.destructuredParameters[1]
+  assert.equal(fooParam.name, 'foo', 'Second property name should be foo')
+  assert.equal(fooParam.definition, 'fooValue', 'Second property alias should be fooValue')
+})
+
+test('should handle nested objects in module.exports', () => {
+  const code = `
+module.exports = {
+  handlers: {
+    hello: function() {},
+    world: function() {}
+  },
+  config: {
+    foo: 'bar'
+  }
+}
+`
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find 1 module.exports assignment')
+  assert.equal(foundExports[0].exportType, 'default')
+  assert.equal(foundExports[0].definitions.destructuredParameters.length, 2, 'Should have 2 top-level keys')
+  assert.equal(foundExports[0].definitions.destructuredParameters[0].name, 'handlers')
+  assert.equal(foundExports[0].definitions.destructuredParameters[1].name, 'config')
+})
+
+test('should handle module.exports assignment with additional properties', () => {
+  const code = `
+module.exports = function main() {}
+module.exports.foo = function() {}
+module.exports.bar = function() {}
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 3, 'Should find 3 exports')
+
+  // Check main function assignment
+  const mainExport = foundExports.find(exp => exp.exportName === '')
+  assert.ok(mainExport, 'Should find main function export')
+  assert.equal(mainExport.exportType, 'default')
+  assert.equal(mainExport.exportValue, 'function main() {}')
+
+  // Check foo property
+  const fooExport = foundExports.find(exp => exp.exportName === 'foo')
+  assert.ok(fooExport, 'Should find foo property export')
+  assert.equal(fooExport.exportType, 'named')
+
+  // Check bar property
+  const barExport = foundExports.find(exp => exp.exportName === 'bar')
+  assert.ok(barExport, 'Should find bar property export')
+  assert.equal(barExport.exportType, 'named')
+
+  // Check sorting by index
+  assert.ok(foundExports[0].index < foundExports[1].index, 'Exports should be sorted by index')
+  assert.ok(foundExports[1].index < foundExports[2].index, 'Exports should be sorted by index')
+})
+
+test('should not match comments', () => {
+  const code = `
+// module.exports.hello = function() {}
+/* module.exports.world = function() {} */
+const real = 'actual code'
+module.exports.real = real
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should only find 1 real export, not commented ones')
+  assert.equal(foundExports[0].exportName, 'real', 'Should find real export')
+})
+
+test('should handle module.exports in strings', () => {
+  const code = `
+const str = "module.exports.fake = 'test'"
+const str2 = 'module.exports.fake2 = "test"'
+module.exports.real = function() {}
+  `
+
+  const foundExports = getCjsExports(code)
+
+  // Note: Basic regex may catch strings - this test documents current behavior
+  // We may need to improve string detection if this becomes an issue
+  assert.ok(foundExports.length >= 1, 'Should find at least the real export')
+  const realExport = foundExports.find(exp => exp.exportName === 'real')
+  assert.ok(realExport, 'Should find real export')
+})
+
+test('should handle string literal property names', () => {
+  const code = `
+exports['hello-world'] = function() {}
+module.exports['my-config'] = { port: 8080 }
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 2, 'Should find 2 exports with string literal property names')
+
+  const helloWorldExport = foundExports.find(exp => exp.exportName === 'hello-world')
+  assert.ok(helloWorldExport, 'Should find hello-world export')
+  assert.equal(helloWorldExport.exportType, 'named')
+
+  const configExport = foundExports.find(exp => exp.exportName === 'my-config')
+  assert.ok(configExport, 'Should find my-config export')
+  assert.equal(configExport.exportType, 'named')
+})
+
+test('should handle variable property names', () => {
+  const code = `
+const myExportName = 'myFunction'
+exports[myExportName] = () => { /* ... */ }
+  `
+
+  const foundExports = getCjsExports(code)
+
+  // This may not work with simple regex - documenting expected behavior
+  assert.ok(foundExports.length >= 0, 'Variable property names may not be detectable with regex')
+})
+
+test('should handle chained assignment', () => {
+  const code = `
+exports = module.exports = createRouter()
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find chained assignment')
+  assert.equal(foundExports[0].exportType, 'default')
+  assert.equal(foundExports[0].exportValue, 'createRouter()')
+})
+
+test('should handle Object.assign to exports', () => {
+  const code = `
+const utils = {
+  isString() {},
+  isNumber() {}
+}
+const constants = {
+  MAX_RETRIES: 5
+}
+
+Object.assign(exports, utils, constants)
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find Object.assign to exports')
+  assert.equal(foundExports[0].exportType, 'object-assign')
+  assert.equal(foundExports[0].exportName, 'Object.assign')
+  assert.equal(foundExports[0].exportValue, 'Object.assign(exports, utils, constants)')
+})
+
+test('should handle module.exports with Object.assign', () => {
+  const code = `
+const utils = {
+  isString() {},
+  isNumber() {}
+}
+
+module.exports = Object.assign({}, utils, { someOtherExport: 'foo' })
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find module.exports assignment')
+  assert.equal(foundExports[0].exportType, 'object-assign')
+  assert.equal(foundExports[0].exportName, '')
+  assert.ok(foundExports[0].exportValue.includes('Object.assign'), 'Should include Object.assign call')
+})
+
+test('should handle MULTILINE module.exports with Object.assign', () => {
+  const code = `
+const utils = {
+  isString() {},
+  isNumber() {}
+}
+
+module.exports = Object.assign(
+  {},
+  utils,
+  {
+    someOtherExport: 'foo'
+  })
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find module.exports assignment')
+  assert.equal(foundExports[0].exportType, 'object-assign')
+  assert.equal(foundExports[0].exportName, '')
+  assert.ok(foundExports[0].exportValue.includes('Object.assign'), 'Should include Object.assign call')
+  assert.ok(foundExports[0].exportValue.includes('someOtherExport'), 'Should include complete multiline call')
+})
+
+test('should handle object spread in module.exports', () => {
+  const code = `
+const baseConfig = { port: 3000, host: 'localhost' }
+const specificFuncs = {
+  start() {},
+  stop() {}
+}
+
+module.exports = {
+  ...baseConfig,
+  ...specificFuncs,
+  environment: 'development'
+}
+  `
+
+  const foundExports = getCjsExports(code)
+
+  assert.ok(foundExports.length === 1, 'Should find module.exports assignment')
+  assert.equal(foundExports[0].exportType, 'object-spread')
+  assert.equal(foundExports[0].exportName, '')
+  assert.ok(foundExports[0].exportValue.includes('...baseConfig'), 'Should include spread operator')
+  assert.ok(foundExports[0].exportValue.includes('...specificFuncs'), 'Should include spread operator')
+})
+
+test('should ignore comment conflicting values', () => {
+  const code = `
+const baseConfig = { port: 3000, host: 'localhost' }
+const specificFuncs = {
+  start() {},
+  stop() {}
+}
+
+module.exports = {
+  // ...baseConfig,
+  /* ...specificFuncs */
+  baseConfig,
+  specificFuncs,
+  environment: 'development'
+}
+  `
+
+  const foundExports = getCjsExports(code)
+
+
+  // console.log('foundExports', foundExports)
+  // console.log('foundExports', foundExports[0].definitions)
+
+  assert.ok(foundExports.length === 1, 'Should find module.exports assignment')
+  assert.equal(foundExports[0].exportType, 'default')
+  assert.equal(foundExports[0].exportName, '')
+
+  // Comments should be preserved in exportValue
+  assert.ok(foundExports[0].exportValue.includes('// ...baseConfig'), 'Should preserve comments in exportValue')
+  assert.ok(foundExports[0].exportValue.includes('baseConfig'), 'Should include baseConfig')
+  assert.ok(foundExports[0].exportValue.includes('specificFuncs'), 'Should include specificFuncs')
+
+  // Comments should NOT appear in keys array
+  assert.equal(foundExports[0].keys.length, 3, 'Should have 3 keys (no comment lines)')
+  assert.ok(foundExports[0].keys.includes('baseConfig'), 'Keys should include baseConfig')
+  assert.ok(foundExports[0].keys.includes('specificFuncs'), 'Keys should include specificFuncs')
+  assert.ok(foundExports[0].keys.includes('environment'), 'Keys should include environment')
+})
+
+test.run()