api: throw on invalid OBS initialization options

Author: aleksandr-voitenko

js/module.ts

@@ -2060,6 +2060,9 @@ export interface INodeObs {
     /**
      * Initializes the global OBS runtime.
      * @param options - Required runtime initialization options
+     * @returns The OBS video initialization result code
+     * @throws {TypeError} If exactly one options object is not provided, or if a required option is not a string
+     * @throws {Error} If the IPC call fails or OSN returns an error response without an initialization result
      */
     OBS_API_initAPI(options: IOBSAPIInitializationOptions): EVideoCodes;
 }

obs-studio-client/source/nodeobs_api.cpp

@@ -30,9 +30,28 @@
 
 Napi::ThreadSafeFunction js_thread;
 
+namespace {
+
+bool getRequiredStringOption(const Napi::CallbackInfo &info, const Napi::Object &options, const char *name, std::string &value)
+{
+	const Napi::Value option = options.Get(name);
+	if (info.Env().IsExceptionPending())
+		return false;
+
+	if (!option.IsString()) {
+		Napi::TypeError::New(info.Env(), std::string("OBS_API_initAPI option '") + name + "' must be a string").ThrowAsJavaScriptException();
+		return false;
+	}
+
+	value = option.As<Napi::String>().Utf8Value();
+	return true;
+}
+
+} // namespace
+
 Napi::Value api::OBS_API_initAPI(const Napi::CallbackInfo &info)
 {
-	if (info.Length() != 1 || !info[0].IsObject()) {
+	if (info.Length() != 1 || !info[0].IsObject() || info[0].IsArray()) {
 		Napi::TypeError::New(info.Env(), "OBS_API_initAPI expects exactly one initialization options object").ThrowAsJavaScriptException();
 		return info.Env().Undefined();
 	}
@@ -43,10 +62,10 @@ Napi::Value api::OBS_API_initAPI(const Napi::CallbackInfo &info)
 	std::string crashserverurl;
 
 	const Napi::Object options = info[0].As<Napi::Object>();
-	ASSERT_GET_VALUE(info, options.Get("language"), language);
-	ASSERT_GET_VALUE(info, options.Get("appDataPath"), appDataPath);
-	ASSERT_GET_VALUE(info, options.Get("version"), version);
-	ASSERT_GET_VALUE(info, options.Get("crashServerUrl"), crashserverurl);
+	if (!getRequiredStringOption(info, options, "language", language) || !getRequiredStringOption(info, options, "appDataPath", appDataPath) ||
+	    !getRequiredStringOption(info, options, "version", version) || !getRequiredStringOption(info, options, "crashServerUrl", crashserverurl)) {
+		return info.Env().Undefined();
+	}
 
 	auto conn = GetConnection(info);
 	if (!conn)

tests/osn-tests/src/test_nodeobs_api.ts

@@ -9,6 +9,60 @@ import { showHideInputHotkeys, slideshowHotkeys, ffmpeg_sourceHotkeys,
 
 const testName = 'nodeobs_api';
 
+const validInitializationOptions: osn.IOBSAPIInitializationOptions = {
+    language: 'en-US',
+    appDataPath: 'test-app-data',
+    version: '0.00.00-preview.0',
+    crashServerUrl: '',
+};
+
+function callInitialize(...args: unknown[]): unknown {
+    return Reflect.apply(
+        osn.NodeObs.OBS_API_initAPI as (...values: unknown[]) => unknown,
+        osn.NodeObs,
+        args,
+    );
+}
+
+describe(`${testName} initialization validation`, function() {
+    it('requires exactly one non-array options object', function() {
+        const invalidArgumentLists: unknown[][] = [
+            [],
+            [null],
+            [undefined],
+            ['options'],
+            [[]],
+            [validInitializationOptions, validInitializationOptions],
+        ];
+
+        for (const args of invalidArgumentLists) {
+            expect(() => callInitialize(...args)).to.throw(
+                TypeError,
+                'OBS_API_initAPI expects exactly one initialization options object',
+            );
+        }
+    });
+
+    const requiredStringOptions: Array<keyof osn.IOBSAPIInitializationOptions> = [
+        'language',
+        'appDataPath',
+        'version',
+        'crashServerUrl',
+    ];
+
+    for (const optionName of requiredStringOptions) {
+        it(`requires ${optionName} to be a string`, function() {
+            const expectedMessage = `OBS_API_initAPI option '${optionName}' must be a string`;
+            const missingOption: Partial<osn.IOBSAPIInitializationOptions> = { ...validInitializationOptions };
+            delete missingOption[optionName];
+            const invalidOption = { ...validInitializationOptions, [optionName]: 42 };
+
+            expect(() => callInitialize(missingOption)).to.throw(TypeError, expectedMessage);
+            expect(() => callInitialize(invalidOption)).to.throw(TypeError, expectedMessage);
+        });
+    }
+});
+
 describe(testName, function() {
     let obs: OBSHandler;
     let hasTestFailed: boolean = false;