specmatic 2.12.0 → 2.13.2

package/src/bin/command.line.ts

@@ -1,23 +1,10 @@
 import logger from '../common/logger'
-import { callKafka, callCore, callGraphQl } from '../common/runner'
-import yargs from 'yargs/yargs';
-import { hideBin } from 'yargs/helpers';
+import { callCore} from '../common/runner'
 
-const callSpecmaticCli = (args?: string[]) => {
-    args = args || process.argv
-    const argv = yargs(hideBin(args)).parserConfiguration({
-        'camel-case-expansion': false,
-        'boolean-negation': false,
-        'parse-numbers': false,
-        'dot-notation': false,
-        'short-option-groups': false
-    }).parseSync();
-    const { _, $0, ...namedArgs } = argv;
-    const fn = getJarFunction(_);
-    const command = (_.join(' ') + ' ' + Object.entries(namedArgs).map(([key, value]) => `--${key}="${String(value)}"`).join(' ')).trim();
-    logger.info(`CLI: Running with args "${command}"`);
-    fn(
-        command,
+const callSpecmaticCli = (argsv?: string[]) => {
+    const args = argsv || process.argv.slice(2);
+    callCore(
+        args,
         (err?: any) => {
             if (err) {
                 logger.info('CLI: Finished with non zero exit code: ', err.code)
@@ -33,20 +20,4 @@ const callSpecmaticCli = (args?: string[]) => {
     );
 }
 
-function getJarFunction(operation: any[]) {
-    if(operation.length > 0) {
-        switch (String(operation[0])) {
-            case 'kafka':
-                operation.splice(0,1);
-                return callKafka
-            case 'graphql':
-                operation.splice(0,1);
-                return callGraphQl
-            default:
-                return callCore
-        }
-    }
-    return callCore
-}
-
 export default callSpecmaticCli

package/src/common/runner.ts

@@ -1,37 +1,26 @@
 import execSh from 'exec-sh';
 import path from 'path';
-import { specmaticCoreJarName, specmaticKafkaJarName, specmaticGraphQlJarName } from '../config';
+import { specmaticCoreJarName } from '../config';
 import logger from '../common/logger';
-import { ChildProcess, spawn, SpawnOptions } from 'child_process';
+import { ChildProcess, exec, spawn, SpawnOptions } from 'child_process';
 
-const callCore = (args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void): ChildProcess => {
+const callCore = (args: (string | number)[], done: (error: any) => void, onOutput: (message: string, error: boolean) => void): ChildProcess => {
     const rootPath = path.resolve(__dirname, '..', '..');
     const specmaticJarPath = path.resolve(rootPath, specmaticCoreJarName);
-    logger.debug(`CLI: Specmatic jar path: ${specmaticJarPath}`);
     return callJar(specmaticJarPath, args, done, onOutput);
 };
 
-const callKafka = (args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void): ChildProcess => {
-    const rootPath = path.resolve(__dirname, '..', '..', '..', 'specmatic-commercial', 'kafka');
-    const specmaticJarPath = path.resolve(rootPath, specmaticKafkaJarName);
-    logger.debug(`CLI: Specmatic jar path: ${specmaticJarPath}`);
-    return callJar(specmaticJarPath, args, done, onOutput);
-};
-
-const callGraphQl = (args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void): ChildProcess => {
-    const rootPath = path.resolve(__dirname, '..', '..', '..', 'specmatic-commercial', 'graphql');
-    const specmaticJarPath = path.resolve(rootPath, specmaticGraphQlJarName);
-    logger.debug(`CLI: Specmatic jar path: ${specmaticJarPath}`);
-    return callJar(specmaticJarPath, args, done, onOutput);
-}
-
-function callJar(jarPath: string, args: string, done: (error: any) => void, onOutput: (message: string, error: boolean) => void) {
-    let argsList = [];
+function callJar(jarPath: string, args: (string | number)[], done: (error: any) => void, onOutput: (message: string, error: boolean) => void) {
+    const argsList: string[] = [];
     if (process.env['endpointsAPI']) {
         argsList.push(`-DendpointsAPI="${process.env['endpointsAPI']}"`);
     }
-    argsList = argsList.concat(['-jar', `"${jarPath}"`, args]);
-    const javaProcess: ChildProcess = spawn('java', argsList, { stdio: 'pipe', stderr: 'pipe', shell: true, env: process.env } as SpawnOptions);
+    argsList.push(...['-jar', jarPath]);
+    argsList.push(...args.map(arg => String(arg)));
+    const prettyPrintedCLIArgs = [`java`, ...argsList].map(arg => JSON.stringify(arg)).join(' ');
+
+    logger.info(`CLI: Running command: ${prettyPrintedCLIArgs}`);
+    const javaProcess: ChildProcess = spawn('java', argsList, { stdio: 'pipe', stderr: 'pipe', shell: false, env: process.env } as SpawnOptions);
     javaProcess.stdout?.on('data', function (data: String) {
         onOutput(`${data}`, false);
     });
@@ -48,4 +37,4 @@ function callJar(jarPath: string, args: string, done: (error: any) => void, onOu
     return javaProcess;
 }
 
-export { callCore, callKafka, callGraphQl };
+export { callCore };

package/src/config.ts

@@ -1,3 +1 @@
 export const specmaticCoreJarName = 'specmatic.jar';
-export const specmaticKafkaJarName = 'specmatic-kafka-all.jar';
-export const specmaticGraphQlJarName = 'specmatic-graphql-all.jar';

package/src/core/__tests__/print.jar.version.ts

@@ -23,6 +23,6 @@ test('prints bundled jar version', () => {
 
     specmatic.printJarVersion();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe('--version');
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), `--version`]);
 });

package/src/core/__tests__/stub.ts

@@ -40,8 +40,8 @@ test('should be able to parse stub port on random assignment', async () => {
 
     await expect(specmatic.startStub()).resolves.toStrictEqual(new Stub(HOST, 1234, `http://${HOST}:1234`, javaProcessMock));
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe("stub");
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), "stub"]);
 });
 
 
@@ -55,8 +55,8 @@ test('should stick to random port assignment even if later logs contradict it',
 
     await expect(specmatic.startStub()).resolves.toStrictEqual(new Stub(HOST, 1234, `http://${HOST}:1234`, javaProcessMock));
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe("stub");
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), "stub"]);
 });
 
 
@@ -70,8 +70,8 @@ test('should stick to passed port assignment even if final log contradicts it',
 
     await expect(specmatic.startStub(HOST, 1234)).resolves.toStrictEqual(new Stub(HOST, 1234, `http://${HOST}:1234`, javaProcessMock));
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=1234`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=1234`]);
 });
 
 test('should be able to parse stub port even if the multi base url has postfix paths', async () => {
@@ -83,8 +83,8 @@ test('should be able to parse stub port even if the multi base url has postfix p
 
     await expect(specmatic.startStub(HOST, 1234)).resolves.toStrictEqual(new Stub(HOST, 1234, `http://${HOST}:1234/api`, javaProcessMock));
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=1234`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=1234`]);
 });
 
 
@@ -97,8 +97,8 @@ test('should be able to parse stub port even if the multi base url has postfix p
 
     await expect(specmatic.startStub(HOST, 1234)).resolves.toStrictEqual(new Stub(HOST, 1234, `http://${HOST}:1234/api`, javaProcessMock));
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=1234`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=1234`]);
 });
 
 test('should use the default http or https port when no port is specified in the multi base url logs', async () => {
@@ -110,8 +110,8 @@ test('should use the default http or https port when no port is specified in the
 
     await expect(specmatic.startStub(HOST)).resolves.toStrictEqual(new Stub(HOST, 80, `http://${HOST}:80/api`, javaProcessMock));
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`]);
 });
 
 test('should fail if specified port in logs is out of valid range', async () => {
@@ -138,16 +138,16 @@ test('should pick the first port when multi-port stub is being used', async () =
         "    1. ./simple9002.yaml",
         "    2. ./simple9002Second.yaml"
     ];
-    
+
     setTimeout(() => {
         const messageCallback = readableMock.on.mock.calls[0][1];
         messages.forEach(messageCallback);
-    }, 0);    
+    }, 0);
 
     await expect(specmatic.startStub()).resolves.toStrictEqual(new Stub(HOST, 1234, `http://${HOST}:1234`, javaProcessMock));
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe("stub");
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), "stub"]);
 });
 
 test('test with multi port stub and random port assignment', async () => {
@@ -161,16 +161,16 @@ test('test with multi port stub and random port assignment', async () => {
         "!@! http://localhost:9001 serving endpoints from specs #$!",
         "    1. ./simple9001.yaml",
     ];
-    
+
     setTimeout(() => {
         const messageCallback = readableMock.on.mock.calls[0][1];
         messages.forEach(messageCallback);
-    }, 0);    
+    }, 0);
 
     await expect(specmatic.startStub()).resolves.toStrictEqual(new Stub(HOST, 1234, `http://${HOST}:1234`, javaProcessMock));
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe("stub");
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), "stub"]);
 });
 
 test('starts the specmatic stub server', async () => {
@@ -179,8 +179,8 @@ test('starts the specmatic stub server', async () => {
 
     await expect(specmatic.startStub(HOST, PORT)).resolves.toStrictEqual(stub);
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=${PORT}`]);
 });
 
 test('starts the specmatic stub server with leading and trailing garbage values', async () => {
@@ -189,8 +189,8 @@ test('starts the specmatic stub server with leading and trailing garbage values'
 
     await expect(specmatic.startStub(HOST, PORT)).resolves.toStrictEqual(stub);
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=${PORT}`]);
 });
 
 test('notifies when start fails due to port not available', async () => {
@@ -199,8 +199,8 @@ test('notifies when start fails due to port not available', async () => {
 
     await expect(specmatic.startStub(HOST, PORT)).toReject();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=${PORT}`]);
 });
 
 test('returns host, port and stub url', async () => {
@@ -215,8 +215,8 @@ test('returns host, port and stub url', async () => {
 
     await expect(specmatic.startStub(HOST, PORT)).resolves.toStrictEqual(stub);
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=${PORT}`]);
 });
 
 test('fails if stub url is not available in start up message', async () => {
@@ -225,8 +225,9 @@ test('fails if stub url is not available in start up message', async () => {
 
     await expect(specmatic.startStub(HOST, PORT)).toReject();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=${PORT}`]);
+
 });
 
 test('fails if host info is not available in start up message', async () => {
@@ -236,8 +237,8 @@ test('fails if host info is not available in start up message', async () => {
 
     await expect(specmatic.startStub(HOST, PORT)).toReject();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=${PORT}`]);
 });
 
 test('host and port are optional', async () => {
@@ -246,18 +247,8 @@ test('host and port are optional', async () => {
 
     await expect(specmatic.startStub()).resolves.toStrictEqual(stub);
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe('stub');
-});
-
-test('takes additional pass through arguments', async () => {
-    spawn.mockReturnValue(javaProcessMock);
-    setTimeout(() => readableMock.on.mock.calls[0][1](`- ${stubUrl} serving endpoints from specs:`), 0);
-
-    await expect(specmatic.startStub(HOST, PORT, ['p1', 'p2'])).resolves.toStrictEqual(stub);
-
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT} p1 p2`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), "stub"]);
 });
 
 test('additional pass through arguments can be string or number', async () => {
@@ -266,8 +257,9 @@ test('additional pass through arguments can be string or number', async () => {
 
     await expect(specmatic.startStub(HOST, PORT, ['p1', 123])).resolves.toStrictEqual(stub);
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`stub --host=${HOST} --port=${PORT} p1 123`);
+
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual(['-jar', path.resolve(SPECMATIC_JAR_PATH), "stub", `--host=${HOST}`, `--port=${PORT}`, "p1", "123"]);
 });
 
 test('stopStub method stops any running stub server', async () => {

package/src/core/__tests__/test.ts

@@ -34,8 +34,8 @@ test('runs the contract tests', async function () {
 
     await expect(specmatic.test(HOST, PORT, CONTRACT_FILE_PATH)).resolves.toBeTruthy();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`test ${path.resolve(CONTRACT_FILE_PATH)} --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), 'test', path.resolve(CONTRACT_FILE_PATH), '--junitReportDir=dist/test-report', `--host=${HOST}`, `--port=${PORT}`]);
 });
 
 test('takes additional pass through arguments', async () => {
@@ -47,8 +47,8 @@ test('takes additional pass through arguments', async () => {
 
     await expect(specmatic.test(HOST, PORT, CONTRACT_FILE_PATH, ['P1', 'P2'])).resolves.toBeTruthy();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`test ${path.resolve(CONTRACT_FILE_PATH)} --junitReportDir=dist/test-report --host=${HOST} --port=${PORT} P1 P2`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), 'test', path.resolve(CONTRACT_FILE_PATH), '--junitReportDir=dist/test-report', `--host=${HOST}`, `--port=${PORT}`, 'P1', 'P2']);
 });
 
 test('additional pass through arguments can be string or number', async () => {
@@ -60,8 +60,8 @@ test('additional pass through arguments can be string or number', async () => {
 
     await expect(specmatic.test(HOST, PORT, CONTRACT_FILE_PATH, ['P1', 123])).resolves.toBeTruthy();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`test ${path.resolve(CONTRACT_FILE_PATH)} --junitReportDir=dist/test-report --host=${HOST} --port=${PORT} P1 123`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), 'test', path.resolve(CONTRACT_FILE_PATH), '--junitReportDir=dist/test-report', `--host=${HOST}`, `--port=${PORT}`, 'P1', '123']);
 });
 
 test('runs the contract tests with host and port optional', async function () {
@@ -73,8 +73,8 @@ test('runs the contract tests with host and port optional', async function () {
 
     await expect(specmatic.test()).resolves.toBeTruthy();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`test --junitReportDir=dist/test-report`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), 'test', '--junitReportDir=dist/test-report']);
 });
 
 test('runs the contract tests with contracts path optional', async function () {
@@ -86,8 +86,8 @@ test('runs the contract tests with contracts path optional', async function () {
 
     await expect(specmatic.test(HOST, PORT)).resolves.toBeTruthy();
 
-    expect(spawn.mock.calls[0][1][1]).toBe(`"${path.resolve(SPECMATIC_JAR_PATH)}"`);
-    expect(spawn.mock.calls[0][1][2]).toBe(`test --junitReportDir=dist/test-report --host=${HOST} --port=${PORT}`);
+    expect(spawn.mock.calls[0][0]).toBe(`java`);
+    expect(spawn.mock.calls[0][1]).toEqual([`-jar`, path.resolve(SPECMATIC_JAR_PATH), 'test', '--junitReportDir=dist/test-report', `--host=${HOST}`, `--port=${PORT}`]);
 });
 
 test('runs the contract tests and returns a summary', async function () {

package/src/core/index.ts

@@ -27,10 +27,10 @@ export class Stub {
 }
 
 const startStub = (host?: string, port?: number, args?: (string | number)[]): Promise<Stub> => {
-    var cmd = `stub`
-    if (host) cmd += ` --host=${host}`
-    if (port) cmd += ` --port=${port}`
-    if (args) cmd += ' ' + args.join(' ')
+    var cmd = [`stub`]
+    if (host) cmd .push(`--host=${host}`)
+    if (port) cmd .push(`--port=${port}`)
+    if (args) cmd .push(...args.map(arg => String(arg)))
 
     logger.info('Stub: Starting server')
     logger.debug(`Stub: Executing "${cmd}"`)
@@ -76,7 +76,7 @@ function extractErrorMessage(error: any): string {
     if (typeof error === 'string') {
       return error;
     }
-    
+
     if (error instanceof Error) {
       return error.message;
     }
@@ -91,18 +91,18 @@ function parseStubOutput(
 ): Stub {
     const url = stubInfo[0].trim();
     const urlInfo = /\b(.*?):\/\/(.*?):?([0-9]+)?(\/.*)?$/.exec(url);
-    
+
     if (urlInfo === null || !urlInfo[1] || !urlInfo[2]) {
       throw new Error('Cannot determine host and port from stub output');
     }
-  
+
     const protocol = urlInfo[1];
     const host = urlInfo[2];
     const regexPort = urlInfo[3];
     const path = urlInfo[4] || "";
     const defaultPort = protocol === 'http' ? '80' : protocol === 'https' ? '443' : undefined;
     const finalPort = parsedPort ?? regexPort ?? defaultPort;
-    
+
     if (!finalPort) {
       throw new Error('Cannot determine port from stub output');
     }
@@ -147,12 +147,12 @@ const testWithApiCoverage = async (
 const test = (host?: string, port?: number, contractPath?: string, args?: (string | number)[]): Promise<{ [k: string]: number } | undefined> => {
     const specsPath = path.resolve(contractPath + '')
 
-    var cmd = `test`
-    if (contractPath) cmd += ` ${specsPath}`
-    cmd += ' --junitReportDir=dist/test-report'
-    if (host) cmd += ` --host=${host}`
-    if (port) cmd += ` --port=${port}`
-    if (args) cmd += ' ' + args.join(' ')
+    const cmd = [`test`]
+    if (contractPath) cmd.push(specsPath)
+    cmd.push('--junitReportDir=dist/test-report')
+    if (host) cmd.push(`--host=${host}`)
+    if (port) cmd.push(`--port=${port}`)
+    if (args) cmd.push(...args.map(arg => String(arg)))
 
     logger.info('Test: Running')
     logger.debug(`Test: Executing "${cmd}"`)
@@ -207,7 +207,7 @@ const setExpectations = (stubPath: string, stubServerBaseUrl?: string): Promise<
 
 const setExpectationJson = (stubResponse: any, stubServerBaseUrl?: string): Promise<void> => {
     stubServerBaseUrl = stubServerBaseUrl || 'http://localhost:9000'
-    
+
     logger.info(`Set Expectations: Stub url is ${stubServerBaseUrl}`)
 
     return new Promise((resolve, reject) => {
@@ -237,7 +237,7 @@ const setExpectationJson = (stubResponse: any, stubServerBaseUrl?: string): Prom
 }
 
 const printJarVersion = () => {
-    const cmd = `--version`
+    const cmd = [`--version`]
     logger.info('Print Jar Version: Running')
     logger.debug(`Print Jar Version: Executing "${cmd}"`)
 

package/src/index.ts

@@ -12,19 +12,3 @@ export {
 	printJarVersion,
 	showTestResults,
 } from "./core";
-export {
-	startKafkaStub,
-	startKafkaStub as startKafkaMock,
-	stopKafkaStub,
-	stopKafkaStub as stopKafkaMock,
-	verifyKafkaStubMessage,
-	verifyKafkaStubMessage as verifyKafkaMockMessage,
-	verifyKafkaStub,
-	verifyKafkaStub as verifyKafkaMock,
-	setKafkaStubExpectations,
-	setKafkaStubExpectations as setKafkaMockExpectations,
-} from "./kafka";
-export {
-	startGraphQlStub,
-	stopGraphQlStub,
-} from "./graphql";

package/dist/graphql/index.d.ts

@@ -1,11 +0,0 @@
-import type { ChildProcess } from "node:child_process";
-export declare class GraphQlStub {
-    host: string;
-    port: number;
-    data?: string;
-    process: ChildProcess;
-    constructor(host: string, port: number, process: ChildProcess, data?: string);
-}
-declare const startGraphQlStub: (host?: string, port?: string, data?: string, args?: (string | number)[]) => Promise<GraphQlStub>;
-declare const stopGraphQlStub: (graphQlStub: GraphQlStub) => Promise<void>;
-export { startGraphQlStub, stopGraphQlStub };