adds support for core base path (#253)

Co-authored-by: Rishabh <[email protected]>

Author: rishabhpoddar

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 -   Added userId as an optional property to the response of `recipe/user/password/reset`.
 -   Fixes https://github.com/supertokens/supertokens-node/issues/244 - throws an error if a user tries to update email / password of a third party login user.
+-   Adds ability to give a path for each of the hostnames in the connectionURI: https://github.com/supertokens/supertokens-node/issues/252
 -   add workflow to verify if pr title follows conventional commits
 
 ## [8.5.0] - 2022-01-14

lib/build/querier.d.ts

@@ -22,19 +22,22 @@ import { PROCESS_STATE, ProcessState } from "./processState";
 
 export class Querier {
     private static initCalled = false;
-    private static hosts: NormalisedURLDomain[] | undefined = undefined;
+    private static hosts: { domain: NormalisedURLDomain; basePath: NormalisedURLPath }[] | undefined = undefined;
     private static apiKey: string | undefined = undefined;
     private static apiVersion: string | undefined = undefined;
 
     private static lastTriedIndex = 0;
     private static hostsAliveForTesting: Set<string> = new Set<string>();
 
-    private __hosts: NormalisedURLDomain[] | undefined;
+    private __hosts: { domain: NormalisedURLDomain; basePath: NormalisedURLPath }[] | undefined;
     private rIdToCore: string | undefined;
 
     // we have rIdToCore so that recipes can force change the rId sent to core. This is a hack until the core is able
     // to support multiple rIds per API
-    private constructor(hosts: NormalisedURLDomain[] | undefined, rIdToCore?: string) {
+    private constructor(
+        hosts: { domain: NormalisedURLDomain; basePath: NormalisedURLPath }[] | undefined,
+        rIdToCore?: string
+    ) {
         this.__hosts = hosts;
         this.rIdToCore = rIdToCore;
     }
@@ -92,7 +95,7 @@ export class Querier {
         return new Querier(Querier.hosts, rIdToCore);
     }
 
-    static init(hosts?: NormalisedURLDomain[], apiKey?: string) {
+    static init(hosts?: { domain: NormalisedURLDomain; basePath: NormalisedURLPath }[], apiKey?: string) {
         if (!Querier.initCalled) {
             Querier.initCalled = true;
             Querier.hosts = hosts;
@@ -245,14 +248,15 @@ export class Querier {
         if (numberOfTries === 0) {
             throw Error("No SuperTokens core available to query");
         }
-        let currentHost: string = this.__hosts[Querier.lastTriedIndex].getAsStringDangerous();
+        let currentDomain: string = this.__hosts[Querier.lastTriedIndex].domain.getAsStringDangerous();
+        let currentBasePath: string = this.__hosts[Querier.lastTriedIndex].basePath.getAsStringDangerous();
         Querier.lastTriedIndex++;
         Querier.lastTriedIndex = Querier.lastTriedIndex % this.__hosts.length;
         try {
             ProcessState.getInstance().addState(PROCESS_STATE.CALLING_SERVICE_IN_REQUEST_HELPER);
-            let response = await axiosFunction(currentHost + path.getAsStringDangerous());
+            let response = await axiosFunction(currentDomain + currentBasePath + path.getAsStringDangerous());
             if (process.env.TEST_MODE === "testing") {
-                Querier.hostsAliveForTesting.add(currentHost);
+                Querier.hostsAliveForTesting.add(currentDomain + currentBasePath);
             }
             if (response.status !== 200) {
                 throw response;

lib/build/querier.js

@@ -52,7 +52,12 @@ export default class SuperTokens {
             config.supertokens?.connectionURI
                 .split(";")
                 .filter((h) => h !== "")
-                .map((h) => new NormalisedURLDomain(h.trim())),
+                .map((h) => {
+                    return {
+                        domain: new NormalisedURLDomain(h.trim()),
+                        basePath: new NormalisedURLPath(h.trim()),
+                    };
+                }),
             config.supertokens?.apiKey
         );
 

lib/build/supertokens.js

@@ -12,7 +12,7 @@
  * License for the specific language governing permissions and limitations
  * under the License.
  */
-const { printPath, setupST, startST, killAllST, cleanST } = require("./utils");
+const { printPath, setupST, startST, killAllST, cleanST, setKeyValueInConfig } = require("./utils");
 let ST = require("../");
 let { Querier } = require("../lib/build/querier");
 let assert = require("assert");
@@ -23,6 +23,8 @@ let nock = require("nock");
 const { default: NormalisedURLPath } = require("../lib/build/normalisedURLPath");
 let EmailPassword = require("../recipe/emailpassword");
 let EmailPasswordRecipe = require("../lib/build/recipe/emailpassword/recipe").default;
+const { default: axios } = require("axios");
+const { fail } = require("assert");
 
 describe(`Querier: ${printPath("[test/querier.test.js]")}`, function () {
     beforeEach(async function () {
@@ -271,4 +273,109 @@ describe(`Querier: ${printPath("[test/querier.test.js]")}`, function () {
 
         assert((await Session.getSessionInformation("someHandle")) === "someHandle");
     });
+
+    it("test with core base path", async function () {
+        // first we need to know if the core used supports base_path config
+        setKeyValueInConfig("base_path", "/test");
+        await startST();
+
+        let response = await axios.get("http://localhost:8080/test/hello");
+        if (response.status === 404) {
+            //core must be an older version, so we return early
+            return;
+        } else if (response.status !== 200) {
+            throw new Error("test failed");
+        }
+
+        ST.init({
+            supertokens: {
+                connectionURI: "http://localhost:8080/test",
+            },
+            appInfo: {
+                apiDomain: "api.supertokens.io",
+                appName: "SuperTokens",
+                websiteDomain: "supertokens.io",
+            },
+            recipeList: [Session.init()],
+        });
+
+        // we query the core now
+        let res = await Session.getAllSessionHandlesForUser("user1");
+        assert(res.length === 0);
+    });
+
+    it("test with incorrect core base path should fail", async function () {
+        // first we need to know if the core used supports base_path config
+        setKeyValueInConfig("base_path", "/some/path");
+        await startST();
+
+        let response = await axios.get("http://localhost:8080/some/path/hello");
+        if (response.status === 404) {
+            //core must be an older version, so we return early
+            return;
+        } else if (response.status !== 200) {
+            throw new Error("test failed");
+        }
+
+        ST.init({
+            supertokens: {
+                connectionURI: "http://localhost:8080/test",
+            },
+            appInfo: {
+                apiDomain: "api.supertokens.io",
+                appName: "SuperTokens",
+                websiteDomain: "supertokens.io",
+            },
+            recipeList: [Session.init()],
+        });
+
+        try {
+            // we query the core now
+            await Session.getAllSessionHandlesForUser("user1");
+            fail();
+        } catch (err) {
+            assert(err.message.startsWith("SuperTokens core threw an error"));
+        }
+    });
+
+    it("test with multiple core base path", async function () {
+        // first we need to know if the core used supports base_path config
+        setKeyValueInConfig("base_path", "/some/path");
+        await startST();
+
+        setKeyValueInConfig("base_path", "/test");
+        await startST("localhost", 8082);
+
+        let response = await axios.get("http://localhost:8080/some/path/hello");
+        if (response.status === 404) {
+            //core must be an older version, so we return early
+            return;
+        } else if (response.status !== 200) {
+            throw new Error("test failed");
+        }
+
+        ST.init({
+            supertokens: {
+                connectionURI: "http://localhost:8080/some/path;http://localhost:8082/test",
+            },
+            appInfo: {
+                apiDomain: "api.supertokens.io",
+                appName: "SuperTokens",
+                websiteDomain: "supertokens.io",
+            },
+            recipeList: [Session.init()],
+        });
+
+        {
+            // we query the first core now
+            let res = await Session.getAllSessionHandlesForUser("user1");
+            assert(res.length === 0);
+        }
+
+        {
+            // we query the second core now
+            let res = await Session.getAllSessionHandlesForUser("user1");
+            assert(res.length === 0);
+        }
+    });
 });