fix: better version checking for plugins

niftyvictor · niftyvictor · commit 7db7c02b7688 · 2025-08-04T12:57:34.000+03:00
diff --git a/lib/ts/superTokens.tsx b/lib/ts/superTokens.tsx
@@ -42,6 +42,8 @@ import {
     redirectWithNavigate,
 } from "./utils";
 import { package_version } from "./version";
+import { isVersionCompatible } from "./versionChecker";
+import { package_version as webjs_package_version } from "supertokens-web-js/lib/ts/version";
 
 import type RecipeModule from "./recipe/recipeModule";
 import type { BaseRecipeModule } from "./recipe/recipeModule/baseRecipeModule";
@@ -218,14 +220,22 @@ export default class SuperTokens {
         if (config.experimental?.plugins) {
             for (const plugin of config.experimental.plugins) {
                 if (plugin.compatibleAuthReactSDKVersions) {
-                    const versionContraints = Array.isArray(plugin.compatibleAuthReactSDKVersions)
-                        ? plugin.compatibleAuthReactSDKVersions
-                        : [plugin.compatibleAuthReactSDKVersions];
-                    if (!versionContraints.includes(package_version)) {
-                        // TODO: better checks
+                    const versionCheck = isVersionCompatible(package_version, plugin.compatibleAuthReactSDKVersions);
+                    if (!versionCheck) {
                         throw new Error(
-                            `Plugin version mismatch. Version ${package_version} not found in compatible versions: ${versionContraints.join(
-                                ", "
+                            `Plugin AuthReact SDK version mismatch. Version ${package_version} not found in compatible versions: ${JSON.stringify(
+                                plugin.compatibleAuthReactSDKVersions
+                            )}`
+                        );
+                    }
+                }
+
+                if (plugin.compatibleWebJSSDKVersions) {
+                    const versionCheck = isVersionCompatible(webjs_package_version, plugin.compatibleWebJSSDKVersions);
+                    if (!versionCheck) {
+                        throw new Error(
+                            `Plugin WebJS SDK version mismatch. Version ${webjs_package_version} not found in compatible versions: ${JSON.stringify(
+                                plugin.compatibleWebJSSDKVersions
                             )}`
                         );
                     }
diff --git a/lib/ts/versionChecker.ts b/lib/ts/versionChecker.ts
@@ -0,0 +1,107 @@
+const parseVersion = (version: string): { major: number; minor: number; patch: number; prerelease?: string } => {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
+    if (!match) {
+        throw new Error(`Invalid version format: ${version}`);
+    }
+
+    return {
+        major: parseInt(match[1]),
+        minor: parseInt(match[2]),
+        patch: parseInt(match[3]),
+        prerelease: match[4],
+    };
+};
+
+const compareVersions = (a: ReturnType<typeof parseVersion>, b: ReturnType<typeof parseVersion>): number => {
+    if (a.major !== b.major) return a.major - b.major;
+    if (a.minor !== b.minor) return a.minor - b.minor;
+    if (a.patch !== b.patch) return a.patch - b.patch;
+
+    // canary versions
+    if (a.prerelease && !b.prerelease) return -1;
+    if (!a.prerelease && b.prerelease) return 1;
+    if (a.prerelease && b.prerelease) {
+        return a.prerelease.localeCompare(b.prerelease);
+    }
+
+    return 0;
+};
+
+// checks if a version satisfies a range constraint. supports: ">=0.49.0", "0.49.x", "~0.49.0", "^0.49.0", "0.49.1"
+const satisfiesRange = (version: string, range: string): boolean => {
+    const parsedVersion = parseVersion(version);
+
+    if (range === version) return true;
+
+    const rangeMatch = range.match(/^([<>=~^]+)\s*(.+)$/);
+    if (rangeMatch) {
+        const operator = rangeMatch[1];
+        const rangeVersion = rangeMatch[2];
+        const parsedRangeVersion = parseVersion(rangeVersion);
+        const comparison = compareVersions(parsedVersion, parsedRangeVersion);
+
+        switch (operator) {
+            case ">=":
+                return comparison >= 0;
+            case ">":
+                return comparison > 0;
+            case "<=":
+                return comparison <= 0;
+            case "<":
+                return comparison < 0;
+            case "=":
+            case "==":
+                return comparison === 0;
+            case "~":
+                return (
+                    parsedVersion.major === parsedRangeVersion.major &&
+                    parsedVersion.minor === parsedRangeVersion.minor &&
+                    parsedVersion.patch >= parsedRangeVersion.patch
+                );
+            case "^":
+                if (parsedRangeVersion.major === 0) {
+                    return (
+                        parsedVersion.major === 0 &&
+                        parsedVersion.minor === parsedRangeVersion.minor &&
+                        parsedVersion.patch >= parsedRangeVersion.patch
+                    );
+                } else {
+                    return (
+                        parsedVersion.major === parsedRangeVersion.major &&
+                        parsedVersion.minor >= parsedRangeVersion.minor
+                    );
+                }
+            default:
+                return false;
+        }
+    }
+
+    // x-ranges like "0.49.x"
+    const xRangeMatch = range.match(/^(\d+)\.(\d+)\.x$/);
+    if (xRangeMatch) {
+        return (
+            parsedVersion.major === parseInt(xRangeMatch[1], 10) && parsedVersion.minor === parseInt(xRangeMatch[2], 10)
+        );
+    }
+
+    // wildcard ranges like "0.x"
+    const wildcardMatch = range.match(/^(\d+)\.x$/);
+    if (wildcardMatch) {
+        return parsedVersion.major === parseInt(wildcardMatch[1], 10);
+    }
+
+    const exactRangeVersion = parseVersion(range);
+    return compareVersions(parsedVersion, exactRangeVersion) === 0;
+};
+
+export const isVersionCompatible = (currentVersion: string, constraints: string | string[]): boolean => {
+    const constraintArray = Array.isArray(constraints) ? constraints : [constraints];
+
+    for (const constraint of constraintArray) {
+        if (satisfiesRange(currentVersion, constraint)) {
+            return true;
+        }
+    }
+
+    return false;
+};
diff --git a/test/unit/versionChecker.test.ts b/test/unit/versionChecker.test.ts
@@ -0,0 +1,49 @@
+/* Copyright (c) 2025, VRAI Labs and/or its affiliates. All rights reserved.
+ *
+ * This software is licensed under the Apache License, Version 2.0 (the
+ * "License") as published by the Apache Software Foundation.
+ *
+ * You may not use this file except in compliance with the License. You may
+ * obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ */
+
+const assert = require("assert");
+import { isVersionCompatible } from "../../lib/ts/versionChecker";
+
+// Test cases
+const testCases = [
+    { version: "0.49.1", constraint: "0.49.1", expected: true },
+    { version: "0.49.1", constraint: ">=0.49.0", expected: true },
+    { version: "0.49.1", constraint: ">0.49.0", expected: true },
+    { version: "0.49.1", constraint: "<=0.49.1", expected: true },
+    { version: "0.49.1", constraint: "<0.50.0", expected: true },
+    { version: "0.49.1", constraint: "=0.49.1", expected: true },
+    { version: "0.49.2", constraint: "~0.49.0", expected: true },
+    { version: "0.49.5", constraint: "~0.49.0", expected: true },
+    { version: "0.50.0", constraint: "~0.49.0", expected: false },
+    { version: "0.49.5", constraint: "^0.49.0", expected: true },
+    { version: "0.50.0", constraint: "^0.49.0", expected: false },
+    { version: "0.49.1", constraint: "0.49.x", expected: true },
+    { version: "0.49.5", constraint: "0.49.x", expected: true },
+    { version: "0.50.0", constraint: "0.49.x", expected: false },
+    { version: "0.49.1", constraint: "0.x", expected: true },
+    { version: "0.50.0", constraint: "0.x", expected: true },
+    { version: "1.0.0", constraint: "0.x", expected: false },
+    { version: "0.49.1", constraint: ["0.49.0", "0.49.1", "0.49.2"], expected: true },
+    { version: "0.49.1", constraint: ["0.48.0", "0.50.0"], expected: false },
+];
+
+describe("versionChecker tests", function () {
+    it("check version compatibility", function () {
+        for (const testCase of testCases) {
+            const result = isVersionCompatible(testCase.version, testCase.constraint);
+            assert.strictEqual(result, testCase.expected);
+        }
+    });
+});
