gh-87 Make scheme parameter optional

Author: thomashacker

src/connection/gqlClient.ts

@@ -9,9 +9,7 @@ export interface GraphQLClient {
 export const gqlClient = (config: ConnectionParams): GraphQLClient => {
   const defaultHeaders = config.headers;
   const version = '/v1/graphql';
-  const baseUri = config.host.startsWith(`${config.scheme}://`)
-    ? `${config.host}${version}`
-    : `${config.scheme}://${config.host}${version}`;
+  const baseUri = `${config.host}${version}`;
 
   return {
     // for backward compatibility with replaced graphql-client lib,

src/connection/httpClient.ts

@@ -15,9 +15,7 @@ export interface HttpClient {
 
 export const httpClient = (config: ConnectionParams): HttpClient => {
   const version = '/v1';
-  const baseUri = config.host.startsWith(`${config.scheme}://`)
-    ? `${config.host}${version}`
-    : `${config.scheme}://${config.host}${version}`;
+  const baseUri = `${config.host}${version}`;
   const url = makeUrl(baseUri);
 
   return {

src/connection/index.ts

@@ -10,11 +10,13 @@ export default class Connection {
   private apiKey?: string;
   private authEnabled: boolean;
   private gql: GraphQLClient;
+  public readonly host: string;
   public readonly http: HttpClient;
   public oidcAuth?: OidcAuthenticator;
 
   constructor(params: ConnectionParams) {
     params = this.sanitizeParams(params);
+    this.host = params.host;
     this.http = httpClient(params);
     this.gql = gqlClient(params);
     this.authEnabled = this.parseAuthParams(params);
@@ -36,10 +38,32 @@ export default class Connection {
   }
 
   private sanitizeParams(params: ConnectionParams) {
+    // Remove trailing slashes from the host
     while (params.host.endsWith('/')) {
       params.host = params.host.slice(0, -1);
     }
 
+    const protocolPattern = /^(https?:\/\/|ftp:\/\/|file:\/\/)/;
+    const extractedSchemeMatch = params.host.match(protocolPattern);
+
+    // Check for the existence of scheme in params
+    if (params.scheme) {
+      // If the host contains a scheme different than provided scheme, replace it and throw a warning
+      if (extractedSchemeMatch && extractedSchemeMatch[0] !== `${params.scheme}://`) {
+        throw new Error(
+          `The host contains a different protocol than specified in the scheme (scheme: ${params.scheme}:// != host: ${extractedSchemeMatch[0]})`
+        );
+      } else if (!extractedSchemeMatch) {
+        // If no scheme in the host, simply prefix with the provided scheme
+        params.host = `${params.scheme}://${params.host}`;
+      }
+      // If there's no scheme in params, ensure the host starts with a recognized protocol
+    } else if (!extractedSchemeMatch) {
+      throw new Error(
+        'The host must start with a recognized protocol (e.g., http:// or https://) if no scheme is provided.'
+      );
+    }
+
     return params;
   }
 

src/connection/unit.test.ts

@@ -124,38 +124,73 @@ describe('mock server auth tests', () => {
     await conn.login().then((key) => expect(key).toEqual(apiKey));
   });
 
-  it('should construct the correct baseUri for conn.http when host contains scheme', async () => {
+  it('should construct the correct url when host contains scheme', () => {
     const apiKey = 'abcd123';
 
     const conn = new Connection({
       scheme: 'http',
       host: 'http://localhost:' + server.port,
       apiKey: new ApiKey(apiKey),
     });
+    const expectedPath = 'http://localhost:' + server.port;
 
-    await conn.http.get('/testEndpoint');
-    const lastRequestURL = server.lastRequest().path; // Get the path of the last request
-    const expectedPath = '/v1/testEndpoint';
-    expect(lastRequestURL).toEqual(expectedPath);
+    expect(conn.host).toEqual(expectedPath);
   });
 
-  it('should construct the correct baseUri for conn.query when host contains scheme', async () => {
+  it('should construct the correct url when scheme specified and host does not contain scheme', () => {
     const apiKey = 'abcd123';
 
     const conn = new Connection({
       scheme: 'http',
+      host: 'localhost:' + server.port,
+      apiKey: new ApiKey(apiKey),
+    });
+    const expectedPath = 'http://localhost:' + server.port;
+
+    expect(conn.host).toEqual(expectedPath);
+  });
+
+  it('should construct the correct url when no scheme is specified but host contains scheme', () => {
+    const apiKey = 'abcd123';
+
+    const conn = new Connection({
       host: 'http://localhost:' + server.port,
       apiKey: new ApiKey(apiKey),
     });
+    const expectedPath = 'http://localhost:' + server.port;
+
+    expect(conn.host).toEqual(expectedPath);
+  });
+
+  it('should throw error when host contains different scheme than specified', () => {
+    const apiKey = 'abcd123';
+
+    const createConnection = () => {
+      return new Connection({
+        scheme: 'https',
+        host: 'http://localhost:' + server.port,
+        apiKey: new ApiKey(apiKey),
+      });
+    };
+
+    expect(createConnection).toThrow(
+      'The host contains a different protocol than specified in the scheme (scheme: https:// != host: http://)'
+    );
+  });
+
+  it('should throw error when scheme not specified and included in host', () => {
+    const apiKey = 'abcd123';
+
+    const createConnection = () => {
+      return new Connection({
+        host: 'localhost:' + server.port,
+        apiKey: new ApiKey(apiKey),
+      });
+    };
 
-    try {
-      await conn.query('{ query { users } }');
-    } catch (error) {
-      // We just want to test the last request path
-    }
-    const lastRequestURL = server.lastRequest().path;
-    const expectedPath = '/v1/graphql';
-    expect(lastRequestURL).toEqual(expectedPath);
+    expect(createConnection).toThrow(
+      'The host must start with a recognized protocol (e.g., http:// or https://) if no scheme is provided.'
+    );
   });
 
   it('shuts down the server', () => {

src/index.ts

@@ -22,7 +22,7 @@ export interface ConnectionParams {
   authClientSecret?: AuthClientCredentials | AuthAccessTokenCredentials | AuthUserPasswordCredentials;
   apiKey?: ApiKey;
   host: string;
-  scheme: string;
+  scheme?: string;
   headers?: HeadersInit;
 }
 
@@ -44,9 +44,6 @@ const app = {
     // check if the URL is set
     if (!params.host) throw new Error('Missing `host` parameter');
 
-    // check if the scheme is set
-    if (!params.scheme) throw new Error('Missing `scheme` parameter');
-
     // check if headers are set
     if (!params.headers) params.headers = {};