feat: introduce javascriptFileExtensions config parameter. (#779)

This config parameter can be used to allow users to debug javascript
files that have extensions other than .js.

src/agent/config.ts

@@ -179,6 +179,15 @@ export interface ResolvedDebugAgentConfig extends GoogleAuthOptions {
    */
   appPathRelativeToRepository?: string;
 
+  /**
+   * The set of file extensions that identify javascript code to be debugged.
+   * By default, only .js files or files with sourcemaps are considered to be
+   * debuggable. This setting can be used to inform the debugger if you have
+   * javascript code in files with extensions other than .js.
+   * Example: ['.js', '.jsz']
+   */
+  javascriptFileExtensions: string[];
+
   /**
    * A function which takes the path of a source file in your repository,
    * a list of your project's Javascript files known to the debugger,
@@ -362,6 +371,7 @@ export const defaultConfig: ResolvedDebugAgentConfig = {
   },
 
   appPathRelativeToRepository: undefined,
+  javascriptFileExtensions: ['.js'],
   pathResolver: undefined,
   logLevel: 1,
   breakpointUpdateIntervalSec: 10,

src/agent/debuglet.ts

@@ -314,16 +314,23 @@ export class Debuglet extends EventEmitter {
     return extend(true, {}, defaultConfig, config, envConfig);
   }
 
+  static buildRegExp(fileExtensions: string[]): RegExp {
+    return new RegExp(fileExtensions.map(f => f + '$').join('|'));
+  }
+
   static async findFiles(
-    baseDir: string,
+    config: ResolvedDebugAgentConfig,
     precomputedHash?: string
   ): Promise<FindFilesResult> {
+    const baseDir = config.workingDirectory;
     const fileStats = await scanner.scan(
       baseDir,
-      /.js$|.js.map$/,
+      Debuglet.buildRegExp(config.javascriptFileExtensions.concat('js.map')),
       precomputedHash
     );
-    const jsStats = fileStats.selectStats(/.js$/);
+    const jsStats = fileStats.selectStats(
+      Debuglet.buildRegExp(config.javascriptFileExtensions)
+    );
     const mapFiles = fileStats.selectFiles(/.js.map$/, process.cwd());
     const errors = fileStats.errors();
     return {jsStats, mapFiles, errors, hash: fileStats.hash};
@@ -370,10 +377,7 @@ export class Debuglet extends EventEmitter {
 
     let findResults: FindFilesResult;
     try {
-      findResults = await Debuglet.findFiles(
-        that.config.workingDirectory,
-        gaeId
-      );
+      findResults = await Debuglet.findFiles(that.config, gaeId);
       findResults.errors.forEach(that.logger.warn);
     } catch (err) {
       that.logger.error('Error scanning the filesystem.', err);

src/agent/v8/inspector-debugapi.ts

@@ -136,7 +136,8 @@ export class InspectorDebugApi implements debugapi.DebugApi {
     }
     const baseScriptPath = path.normalize(breakpoint.location.path);
     if (!this.sourcemapper.hasMappingInfo(baseScriptPath)) {
-      if (!baseScriptPath.endsWith('js')) {
+      const extension = path.extname(baseScriptPath);
+      if (!this.config.javascriptFileExtensions.includes(extension)) {
         return utils.setErrorStatusAndCallback(
           cb,
           breakpoint,

src/agent/v8/legacy-debugapi.ts

@@ -132,7 +132,8 @@ export class V8DebugApi implements debugapi.DebugApi {
     }
     const baseScriptPath = path.normalize(breakpoint.location.path);
     if (!this.sourcemapper.hasMappingInfo(baseScriptPath)) {
-      if (!baseScriptPath.endsWith('.js')) {
+      const extension = path.extname(baseScriptPath);
+      if (!this.config.javascriptFileExtensions.includes(extension)) {
         return utils.setErrorStatusAndCallback(
           cb,
           breakpoint,

test/fixtures/hello.jsz

@@ -0,0 +1 @@
+console.log('hello world');

test/test-debuglet.ts

@@ -91,20 +91,23 @@ describe('Debuglet', () => {
     const SOURCEMAP_DIR = path.join(__dirname, 'fixtures', 'sourcemaps');
 
     it('throws an error for an invalid directory', async () => {
+      const config = extend({}, defaultConfig, {
+        workingDirectory: path.join(SOURCEMAP_DIR, '!INVALID'),
+      });
       let err: Error | null = null;
       try {
-        await Debuglet.findFiles(
-          path.join(SOURCEMAP_DIR, '!INVALID!'),
-          'fake-id'
-        );
+        await Debuglet.findFiles(config, 'fake-id');
       } catch (e) {
         err = e;
       }
       assert.ok(err);
     });
 
     it('finds the correct sourcemaps files', async () => {
-      const searchResults = await Debuglet.findFiles(SOURCEMAP_DIR, 'fake-id');
+      const config = extend({}, defaultConfig, {
+        workingDirectory: SOURCEMAP_DIR,
+      });
+      const searchResults = await Debuglet.findFiles(config, 'fake-id');
       assert(searchResults.jsStats);
       assert.strictEqual(Object.keys(searchResults.jsStats).length, 1);
       assert(searchResults.jsStats[path.join(SOURCEMAP_DIR, 'js-file.js')]);
@@ -717,9 +720,10 @@ describe('Debuglet', () => {
       // Don't actually scan the entire filesystem.  Act like the filesystem
       // is empty.
       mockedDebuglet.Debuglet.findFiles = (
-        baseDir: string,
+        config: ResolvedDebugAgentConfig,
         precomputedHash?: string
       ): Promise<FindFilesResult> => {
+        const baseDir = config.workingDirectory;
         assert.strictEqual(baseDir, root);
         return Promise.resolve({
           jsStats: {},

test/test-v8debugapi.ts

@@ -244,6 +244,7 @@ describe('v8debugapi', () => {
   const config: ResolvedDebugAgentConfig = extend({}, defaultConfig, {
     workingDirectory: __dirname,
     forceNewAgent_: true,
+    javascriptFileExtensions: ['.js', '.jsz'],
   });
   const logger = consoleLogLevel({
     level: Debuglet.logLevelToName(config.logLevel),
@@ -253,10 +254,10 @@ describe('v8debugapi', () => {
   beforeEach(done => {
     if (!api) {
       scanner
-        .scan(config.workingDirectory, /.js$|.js.map$/)
+        .scan(config.workingDirectory, /.js$|.jsz$|.js.map$/)
         .then(async fileStats => {
           assert.strictEqual(fileStats.errors().size, 0);
-          const jsStats = fileStats.selectStats(/.js$/);
+          const jsStats = fileStats.selectStats(/.js$|.jsz$/);
           const mapFiles = fileStats.selectFiles(/.js.map$/, process.cwd());
           const mapper = await SourceMapper.create(mapFiles);
 
@@ -322,6 +323,21 @@ describe('v8debugapi', () => {
     });
   });
 
+  it('should permit breakpoints on js files with non-standard extensions', done => {
+    require('./fixtures/hello.jsz');
+    const bp: stackdriver.Breakpoint = ({
+      id: 0,
+      location: {line: 1, path: path.join('fixtures', 'hello.jsz')},
+    } as {}) as stackdriver.Breakpoint;
+    api.set(bp, err1 => {
+      assert.ifError(err1);
+      api.clear(bp, err2 => {
+        assert.ifError(err2);
+        done();
+      });
+    });
+  });
+
   it('should set error for breakpoint in non-js files', done => {
     require('./fixtures/key-bad.json');
     // TODO(dominickramer): Have this actually implement Breakpoint