Move load config from util to RokuDeploy

README.md

@@ -53,14 +53,12 @@ sample rokudeploy.json
 The new release has a few breaking changes that is worth going over in order to prepare developers for what they will need to change when they choose to upgrade.
 
 ### JavaScript functions don't load config files from disk
-In v3, files like `roku-deploy.json` and `bsconfig.json` would be loaded anytime a rokuDeploy function was called through the NodeJS api. This functionality has been removed in v4 so that developers have more control over when the config files are loaded. If your script needs to load the config file values, you can simply call `util.getOptionsFromJson` before calling the desired rokuDeploy function. This will default to load from `rokudeploy.json`. Here's an example:
+In v3, files like `roku-deploy.json` and `bsconfig.json` would be loaded anytime a rokuDeploy function was called through the NodeJS api. This functionality has been removed in v4 so that developers have more control over when the config files are loaded. If your script needs to load the config file values, you can simply call `RokuDeploy.loadOptionsFromJson` before calling the desired rokuDeploy function. This will default to load from `rokudeploy.json`. Here's an example:
 
 ```javascript
 const config = {
-    //get the default options
-    ...rokuDeploy.getOptions(),
-    //override with any values found in the `rokudeploy.json` file. You can specify current working directory here.
-    ...util.getOptionsFromJson({ cwd: process.cwd() })
+    //load options from the `rokudeploy.json` file. You can specify current working directory here.
+    ...RokuDeploy.loadOptionsFromJson({ cwd: process.cwd() })
 };
 await rokuDeploy.sideload(config);
 ```
@@ -70,10 +68,8 @@ We've removed support for loading `bsconfig.json` files. This was introduced in
 
 ```javascript
 const config = {
-    //get the default options
-    ...rokuDeploy.getOptions(),
-    //override with any values found in config file
-    ...util.getOptionsFromJson({ configPath: './bsconfig.json' })
+    //load options from a custom config file
+    ...RokuDeploy.loadOptionsFromJson({ configPath: './bsconfig.json' })
 };
 //call some rokuDeploy function
 await rokuDeploy.sideload(config);

src/RokuDeploy.spec.ts

@@ -4473,6 +4473,78 @@ describe('RokuDeploy', () => {
             });
         });
 
+        describe('loadOptionsFromJson', () => {
+            it('should fill in options from rokudeploy.json', () => {
+                fsExtra.outputJsonSync(s`${rootDir}/rokudeploy.json`, { password: 'password' });
+                expect(
+                    RokuDeploy.loadOptionsFromJson({ cwd: rootDir })
+                ).to.eql({
+                    password: 'password'
+                });
+            });
+
+            it('loads cwd from process', () => {
+                try {
+                    fsExtra.outputJsonSync(s`${process.cwd()}/rokudeploy.json`, { host: '1.2.3.4' });
+                    expect(
+                        RokuDeploy.loadOptionsFromJson()
+                    ).to.eql({
+                        host: '1.2.3.4'
+                    });
+                } finally {
+                    fsExtra.removeSync(s`${process.cwd()}/rokudeploy.json`);
+                }
+            });
+
+            it('catches invalid json with jsonc parser', () => {
+                fsExtra.writeJsonSync(s`${process.cwd()}/rokudeploy.json`, { host: '1.2.3.4' });
+                sinon.stub(fsExtra, 'readFileSync').returns(`
+                    {
+                        "rootDir": "src"
+                `);
+                let ex;
+                try {
+                    RokuDeploy.loadOptionsFromJson();
+                } catch (e) {
+                    ex = e;
+                }
+                expect(ex).to.exist;
+                expect(ex.message.startsWith('Error parsing')).to.be.true;
+                fsExtra.removeSync(s`${process.cwd()}/rokudeploy.json`);
+            });
+
+            it('works when loading stagingDir from rokudeploy.json', () => {
+                sinon.stub(fsExtra, 'existsSync').callsFake((filePath) => {
+                    return true;
+                });
+                sinon.stub(fsExtra, 'readFileSync').returns(`
+                    {
+                        "stagingDir": "./staging-dir"
+                    }
+                `);
+                let loadedOptions = RokuDeploy.loadOptionsFromJson();
+                expect(loadedOptions.stagingDir.endsWith('staging-dir')).to.be.true;
+            });
+
+            it('supports jsonc for rokudeploy.json', () => {
+                fsExtra.writeFileSync(s`${tempDir}/rokudeploy.json`, `
+                    //leading comment
+                    {
+                        //inner comment
+                        "rootDir": "src" //trailing comment
+                    }
+                    //trailing comment
+                `);
+                let loadedOptions = RokuDeploy.loadOptionsFromJson({ cwd: tempDir });
+                expect(loadedOptions.rootDir).to.equal('src');
+            });
+
+            it('returns empty object when config file does not exist', () => {
+                const result = RokuDeploy.loadOptionsFromJson({ cwd: '/nonexistent/path' });
+                expect(result).to.eql({});
+            });
+        });
+
         describe('generateBaseRequestOptions', () => {
             it('uses default timeout', () => {
                 const result = rokuDeploy['generateBaseRequestOptions']('test', { host: 'localhost', password: 'test' });

src/RokuDeploy.ts

@@ -7,9 +7,9 @@ const request = r;
 import * as JSZip from 'jszip';
 import * as errors from './Errors';
 import * as xml2js from 'xml2js';
-import { parse as parseJsonc } from 'jsonc-parser';
+import { parse as parseJsonc, printParseErrorCode, type ParseError } from 'jsonc-parser';
 import { util } from './util';
-import type { FileEntry, RokuDeployConstructorOptions } from './RokuDeployOptions';
+import type { FileEntry, RokuDeployConstructorOptions, RokuDeployOptions } from './RokuDeployOptions';
 import { logger } from '@rokucommunity/logger';
 import * as dayjs from 'dayjs';
 import * as lodash from 'lodash';
@@ -29,6 +29,39 @@ export class RokuDeploy {
         outFile: 'roku-deploy.zip'
     };
 
+    /**
+     * Load options from a rokudeploy.json file. Used by CLI commands to load configuration.
+     * @param options - Optional cwd and configPath settings
+     * @returns The parsed options from the config file, or an empty object if not found
+     */
+    public static loadOptionsFromJson(options?: { cwd?: string; configPath?: string }): RokuDeployOptions {
+        const cwd = options?.cwd ?? process.cwd();
+        const configPath = options?.configPath ?? path.join(cwd, 'rokudeploy.json');
+
+        if (fsExtra.existsSync(configPath)) {
+            const configFileText = fsExtra.readFileSync(configPath).toString();
+            const parseErrors: ParseError[] = [];
+            const fileOptions = parseJsonc(configFileText, parseErrors, {
+                allowEmptyContent: true,
+                allowTrailingComma: true,
+                disallowComments: false
+            });
+            if (parseErrors.length > 0) {
+                throw new Error(`Error parsing "${path.resolve(configPath)}": ` + JSON.stringify(
+                    parseErrors.map(x => {
+                        return {
+                            message: printParseErrorCode(x.error),
+                            offset: x.offset,
+                            length: x.length
+                        };
+                    })
+                ));
+            }
+            return fileOptions;
+        }
+        return {};
+    }
+
     /**
      * Instance-level default options that are merged into every method call
      */

src/commands/CaptureScreenshotCommand.ts

@@ -1,11 +1,11 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class CaptureScreenshotCommand {
     async run(args) {
         args.cwd ??= process.cwd();
 
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.captureScreenshot(options);

src/commands/ConvertToSquashfsCommand.ts

@@ -1,9 +1,9 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class ConvertToSquashfsCommand {
     async run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.convertToSquashfs(options);

src/commands/CreateSignedPackageCommand.ts

@@ -1,11 +1,11 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class CreateSignedPackageCommand {
     async run(args) {
         args.cwd ??= process.cwd();
 
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.createSignedPackage(options);

src/commands/DeleteDevChannelCommand.ts

@@ -1,9 +1,9 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class DeleteDevChannelCommand {
     async run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.deleteDevChannel(options);

src/commands/GetDevIdCommand.ts

@@ -1,9 +1,9 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class GetDevIdCommand {
     async run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         const devId = await rokuDeploy.getDevId(options);

src/commands/GetDeviceInfoCommand.ts

@@ -1,10 +1,9 @@
-import { rokuDeploy } from '../index';
-import { util } from '../util';
+import { rokuDeploy, RokuDeploy, util } from '../index';
 
 export class GetDeviceInfoCommand {
     async run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         const outputPath = await rokuDeploy.getDeviceInfo(options);

src/commands/KeyDownCommand.ts

@@ -1,9 +1,9 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class KeyDownCommand {
     async run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.keyDown(options);

src/commands/KeyPressCommand.ts

@@ -1,9 +1,9 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class KeyPressCommand {
     async run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.keyPress(options);

src/commands/KeyUpCommand.ts

@@ -1,9 +1,9 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class KeyUpCommand {
     async run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.keyUp(options);

src/commands/RekeyDeviceCommand.ts

@@ -1,12 +1,12 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy, util } from '../index';
 import * as path from 'path';
 
 export class RekeyDeviceCommand {
     async run(args) {
         args.cwd ??= process.cwd();
 
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         if (args.pkg) {

src/commands/RemoteControlCommand.ts

@@ -1,11 +1,11 @@
 import * as readline from 'readline';
 import type { RokuKey } from '../index';
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class RemoteControlCommand {
     run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
 

src/commands/SendTextCommand.ts

@@ -1,9 +1,9 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class SendTextCommand {
     async run(args) {
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.sendText(options);

src/commands/SideloadCommand.ts

@@ -1,11 +1,11 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class SideloadCommand {
     async run(args) {
         args.cwd ??= process.cwd();
 
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
 

src/commands/StageCommand.ts

@@ -1,11 +1,11 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class StageCommand {
     async run(args) {
         args.cwd ??= process.cwd();
 
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.stage(options);

src/commands/ZipCommand.ts

@@ -1,11 +1,11 @@
-import { rokuDeploy, util } from '../index';
+import { rokuDeploy, RokuDeploy } from '../index';
 
 export class ZipCommand {
     async run(args) {
         args.cwd ??= process.cwd();
 
         let options = {
-            ...util.getOptionsFromJson(args),
+            ...RokuDeploy.loadOptionsFromJson(args),
             ...args
         };
         await rokuDeploy.zip(options);