@davidwells/extract-deps 0.1.0 → 0.1.1

package/.claude/settings.local.json

@@ -8,7 +8,8 @@
       "Bash(tar:*)",
       "Bash(npm install)",
       "Bash(npm test)",
-      "Bash(npm test:*)"
+      "Bash(npm test:*)",
+      "Bash(npm run types:*)"
     ],
     "deny": [],
     "ask": []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davidwells/extract-deps",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Get imports and requires from a codebase without AST",
   "main": "src/index.js",
   "exports": {

package/src/dep-graph.js

@@ -266,7 +266,8 @@ function buildGraphRecursively(
  * @param {boolean} [options.verifyNodeModules] - If true, verify node_modules packages can be resolved. Default: false
  * @param {boolean} [options.includeNodeModules] - If true, include node_modules package names in the graph. 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 (or package names if includeNodeModules). Returns undefined if buildGraph is false.
+ * @param {boolean} [options.returnErrors] - If true, return { graph, errors } instead of throwing. Default: false
+ * @returns {Map<string, string[]>|{graph: Map, errors: Error[]}|undefined} - Dependency graph, or { graph, errors } if returnErrors is true. Returns undefined if buildGraph is false.
  */
 function depGraph(filePath, options = {}) {
   const {
@@ -275,12 +276,17 @@ function depGraph(filePath, options = {}) {
     verifyNodeModules = false,
     includeNodeModules = false,
     throwOnFirstError = false,
+    returnErrors = false,
   } = options
   const errors = []
   const graph = buildGraph ? new Map() : null
 
   buildGraphRecursively(filePath, errors, throwOnFirstError, verifyGraph, verifyNodeModules, includeNodeModules, graph)
 
+  if (returnErrors) {
+    return { graph, errors }
+  }
+
   if (errors.length > 0) {
     const errorMessage = errors.map((err, idx) => `Dep graph error:\n ${err.message}`).join('\n')
     throw new Error(
@@ -298,10 +304,31 @@ function depGraph(filePath, options = {}) {
  * 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 {{ files: string[], nodeModules: string[] }} - Object with files in topological order and unique node_modules
+ * @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
+ * @param {boolean} [options.returnErrors] - If true, include errors array in result instead of throwing
+ * @returns {{ files: string[], nodeModules: string[], errors?: Error[] }} - Object with files in topological order and unique node_modules
  */
 function resolveDepPaths(filePath, options = {}) {
-  const graph = depGraph(filePath, { ...options, includeNodeModules: true })
+  const { returnErrors = false, ...restOptions } = options
+
+  /** @type {Map<string, string[]>} */
+  let graph
+  /** @type {Error[]} */
+  let errors = []
+
+  if (returnErrors) {
+    const result = /** @type {{ graph: Map<string, string[]>, errors: Error[] }} */ (
+      depGraph(filePath, { ...restOptions, includeNodeModules: true, returnErrors: true })
+    )
+    graph = result.graph
+    errors = result.errors
+  } else {
+    graph = /** @type {Map<string, string[]>} */ (
+      depGraph(filePath, { ...restOptions, includeNodeModules: true })
+    )
+  }
 
   // Collect node_modules (non-path strings in dependency arrays)
   const nodeModulesSet = new Set()
@@ -347,10 +374,16 @@ function resolveDepPaths(filePath, options = {}) {
     }
   }
 
-  return {
+  const result = {
     files: buildOrder,
     nodeModules: Array.from(nodeModulesSet)
   }
+
+  if (returnErrors) {
+    result.errors = errors
+  }
+
+  return result
 }
 
 

package/tests/dep-graph.test.js

@@ -438,4 +438,87 @@ test('includeNodeModules works independently of verifyNodeModules', () => {
   assert.ok(indexDeps.includes('lodash'), 'Should include lodash without verification')
 })
 
+// returnErrors tests
+test('returnErrors: true should return { graph, errors } instead of throwing', () => {
+  const fs = require('fs')
+  const testFile = path.resolve(__dirname, 'fixtures/test-return-errors.js')
+
+  fs.writeFileSync(testFile, `
+const missing = require('missing-package-xyz')
+module.exports = { missing }
+`)
+
+  try {
+    const result = depGraph(testFile, { verifyNodeModules: true, returnErrors: true })
+
+    assert.ok(result.graph instanceof Map, 'Should return graph in result')
+    assert.ok(Array.isArray(result.errors), 'Should return errors array')
+    assert.ok(result.errors.length > 0, 'Should have errors for missing package')
+    assert.ok(result.errors[0].message.includes('missing-package-xyz'), 'Error should mention package')
+  } finally {
+    fs.unlinkSync(testFile)
+  }
+})
+
+test('returnErrors: true with no errors returns empty errors array', () => {
+  const result = depGraph(CJS_FIXTURE_PATH, { returnErrors: true })
+
+  assert.ok(result.graph instanceof Map, 'Should return graph')
+  assert.ok(Array.isArray(result.errors), 'Should return errors array')
+  assert.is(result.errors.length, 0, 'Should have no errors')
+})
+
+test('returnErrors: true collects all errors without throwing', () => {
+  const fs = require('fs')
+  const testFile = path.resolve(__dirname, 'fixtures/test-return-multi-errors.js')
+
+  fs.writeFileSync(testFile, `
+const missing1 = require('missing-pkg-1-xyz')
+const missing2 = require('missing-pkg-2-xyz')
+module.exports = { missing1, missing2 }
+`)
+
+  try {
+    const result = depGraph(testFile, { verifyNodeModules: true, returnErrors: true })
+
+    assert.is(result.errors.length, 2, 'Should collect both errors')
+    assert.ok(result.errors.some(e => e.message.includes('missing-pkg-1-xyz')), 'Should have first error')
+    assert.ok(result.errors.some(e => e.message.includes('missing-pkg-2-xyz')), 'Should have second error')
+  } finally {
+    fs.unlinkSync(testFile)
+  }
+})
+
+// resolveDepPaths with returnErrors
+test('resolveDepPaths with returnErrors: true returns { files, nodeModules, errors }', () => {
+  const fs = require('fs')
+  const testFile = path.resolve(__dirname, 'fixtures/test-resolve-return-errors.js')
+
+  fs.writeFileSync(testFile, `
+const missing = require('missing-resolve-pkg-xyz')
+module.exports = { missing }
+`)
+
+  try {
+    const result = resolveDepPaths(testFile, { verifyNodeModules: true, returnErrors: true })
+
+    assert.ok(Array.isArray(result.files), 'Should have files array')
+    assert.ok(Array.isArray(result.nodeModules), 'Should have nodeModules array')
+    assert.ok(Array.isArray(result.errors), 'Should have errors array')
+    assert.ok(result.errors.length > 0, 'Should have errors')
+    assert.ok(result.errors[0].message.includes('missing-resolve-pkg-xyz'), 'Error should mention package')
+  } finally {
+    fs.unlinkSync(testFile)
+  }
+})
+
+test('resolveDepPaths with returnErrors: true and no errors', () => {
+  const result = resolveDepPaths(CJS_FIXTURE_PATH, { returnErrors: true })
+
+  assert.ok(Array.isArray(result.files), 'Should have files')
+  assert.ok(Array.isArray(result.nodeModules), 'Should have nodeModules')
+  assert.ok(Array.isArray(result.errors), 'Should have errors array')
+  assert.is(result.errors.length, 0, 'Should have no errors')
+})
+
 test.run()

package/types/dep-graph.d.ts

@@ -7,7 +7,8 @@
  * @param {boolean} [options.verifyNodeModules] - If true, verify node_modules packages can be resolved. Default: false
  * @param {boolean} [options.includeNodeModules] - If true, include node_modules package names in the graph. 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 (or package names if includeNodeModules). Returns undefined if buildGraph is false.
+ * @param {boolean} [options.returnErrors] - If true, return { graph, errors } instead of throwing. Default: false
+ * @returns {Map<string, string[]>|{graph: Map, errors: Error[]}|undefined} - Dependency graph, or { graph, errors } if returnErrors is true. Returns undefined if buildGraph is false.
  */
 export function depGraph(filePath: string, options?: {
     buildGraph?: boolean;
@@ -15,15 +16,29 @@ export function depGraph(filePath: string, options?: {
     verifyNodeModules?: boolean;
     includeNodeModules?: boolean;
     throwOnFirstError?: boolean;
-}): Map<string, string[]> | undefined;
+    returnErrors?: boolean;
+}): Map<string, string[]> | {
+    graph: Map<any, any>;
+    errors: Error[];
+} | undefined;
 /**
  * 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 {{ files: string[], nodeModules: string[] }} - Object with files in topological order and unique node_modules
+ * @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
+ * @param {boolean} [options.returnErrors] - If true, include errors array in result instead of throwing
+ * @returns {{ files: string[], nodeModules: string[], errors?: Error[] }} - Object with files in topological order and unique node_modules
  */
-export function resolveDepPaths(filePath: string, options?: object): {
+export function resolveDepPaths(filePath: string, options?: {
+    verifyGraph?: boolean;
+    verifyNodeModules?: boolean;
+    throwOnFirstError?: boolean;
+    returnErrors?: boolean;
+}): {
     files: string[];
     nodeModules: string[];
+    errors?: Error[];
 };
 //# sourceMappingURL=dep-graph.d.ts.map

package/types/dep-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dep-graph.d.ts","sourceRoot":"","sources":["../src/dep-graph.js"],"names":[],"mappings":"AAmQA;;;;;;;;;;GAUG;AACH,mCATW,MAAM,YAEd;IAA0B,UAAU,GAA5B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,kBAAkB,GAApC,OAAO;IACW,iBAAiB,GAAnC,OAAO;CACf,GAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAC,SAAS,CAyB3C;AAGD;;;;;GAKG;AACH,0CAJW,MAAM,YACN,MAAM,GACJ;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,CAqDtD"}
+{"version":3,"file":"dep-graph.d.ts","sourceRoot":"","sources":["../src/dep-graph.js"],"names":[],"mappings":"AAmQA;;;;;;;;;;;GAWG;AACH,mCAVW,MAAM,YAEd;IAA0B,UAAU,GAA5B,OAAO;IACW,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,kBAAkB,GAApC,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,YAAY,GAA9B,OAAO;CACf,GAAU,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAC;IAAC,KAAK,gBAAM;IAAC,MAAM,EAAE,KAAK,EAAE,CAAA;CAAC,GAAC,SAAS,CA8BzE;AAGD;;;;;;;;;GASG;AACH,0CARW,MAAM,YAEd;IAA0B,WAAW,GAA7B,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,iBAAiB,GAAnC,OAAO;IACW,YAAY,GAA9B,OAAO;CACf,GAAU;IAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAA;CAAE,CA4ExE"}