@crossmint/common-sdk-auth 0.2.3 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossmint/common-sdk-auth",
-  "version": "0.2.3",
+  "version": "1.0.0",
   "repository": "https://github.com/Crossmint/crossmint-sdk",
   "license": "Apache-2.0",
   "author": "Paella Labs Inc",
@@ -19,10 +19,12 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@crossmint/client-sdk-base": "1.3.1"
+    "@crossmint/client-sdk-base": "1.3.2",
+    "@crossmint/common-sdk-base": "0.3.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --clean --format esm,cjs --outDir ./dist --minify --dts --sourcemap",
-    "dev": "tsup src/index.ts --clean --format esm,cjs --outDir ./dist --dts --sourcemap --watch"
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run"
   }
 }

package/src/CrossmintAuth.test.ts

@@ -0,0 +1,38 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { CrossmintAuth } from "./CrossmintAuth";
+import { type Crossmint, CrossmintApiClient } from "@crossmint/common-sdk-base";
+
+vi.mock("@crossmint/common-sdk-base");
+
+describe("CrossmintAuth", () => {
+    let crossmintAuth: CrossmintAuth;
+    const mockCrossmint = { projectId: "test-project-id" };
+    const mockApiClient = {
+        baseUrl: "https://api.crossmint.com",
+        get: vi.fn(),
+        post: vi.fn(),
+    };
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.mocked(CrossmintApiClient).mockReturnValue(mockApiClient as unknown as CrossmintApiClient);
+        crossmintAuth = CrossmintAuth.from(mockCrossmint as unknown as Crossmint);
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    describe("from", () => {
+        it("should create a new CrossmintAuth instance", () => {
+            expect(crossmintAuth).toBeInstanceOf(CrossmintAuth);
+            expect(CrossmintApiClient).toHaveBeenCalledWith(mockCrossmint, expect.any(Object));
+        });
+    });
+
+    describe("getJwksUri", () => {
+        it("should return the correct JWKS URI", () => {
+            expect(crossmintAuth.getJwksUri()).toBe("https://api.crossmint.com/.well-known/jwks.json");
+        });
+    });
+});

package/src/CrossmintAuth.ts

@@ -0,0 +1,103 @@
+import { type Crossmint, CrossmintApiClient } from "@crossmint/common-sdk-base";
+import { AUTH_SDK_ROOT_ENDPOINT, SDK_NAME, SDK_VERSION } from "./utils/constants";
+import { type AuthMaterialWithUser, CrossmintAuthenticationError, type AuthMaterialResponse } from "./types";
+
+export type CrossmintAuthOptions = {
+    refreshRoute?: string;
+};
+
+export class CrossmintAuth {
+    protected crossmint: Crossmint;
+    protected apiClient: CrossmintApiClient;
+    protected refreshRoute: string | null;
+
+    constructor(crossmint: Crossmint, apiClient: CrossmintApiClient, options: CrossmintAuthOptions = {}) {
+        this.crossmint = crossmint;
+        this.apiClient = apiClient;
+        this.refreshRoute = options.refreshRoute ?? null;
+    }
+
+    public static from(crossmint: Crossmint, options: CrossmintAuthOptions = {}): CrossmintAuth {
+        return new CrossmintAuth(crossmint, CrossmintAuth.defaultApiClient(crossmint), options);
+    }
+
+    public getJwksUri() {
+        return `${this.apiClient.baseUrl}/.well-known/jwks.json`;
+    }
+
+    protected async refreshAuthMaterial(refreshToken?: string): Promise<AuthMaterialWithUser> {
+        if (this.refreshRoute != null) {
+            return await this.refreshFromCustomRoute(refreshToken);
+        }
+
+        if (refreshToken != null) {
+            return await this.refresh(refreshToken);
+        }
+
+        throw new CrossmintAuthenticationError("Refresh token missing from parameters");
+    }
+
+    protected async refresh(refreshToken: string): Promise<AuthMaterialWithUser> {
+        const result = await this.apiClient.post(`${AUTH_SDK_ROOT_ENDPOINT}/refresh`, {
+            body: JSON.stringify({ refresh: refreshToken }),
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+
+        if (!result.ok) {
+            throw new CrossmintAuthenticationError(result.statusText);
+        }
+
+        const resultJson = (await result.json()) as AuthMaterialResponse;
+
+        return {
+            jwt: resultJson.jwt,
+            refreshToken: resultJson.refresh,
+            user: resultJson.user,
+        };
+    }
+
+    private async refreshFromCustomRoute(refreshToken?: string): Promise<AuthMaterialWithUser> {
+        if (!this.refreshRoute) {
+            throw new Error("Custom refresh route is not set");
+        }
+
+        const result = await fetch(this.refreshRoute, {
+            method: "POST",
+            body: JSON.stringify({ refresh: refreshToken }),
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+
+        const resultJson = await result.json();
+        if (!result.ok) {
+            throw new CrossmintAuthenticationError(resultJson.message);
+        }
+
+        return resultJson;
+    }
+
+    protected async logoutFromDefaultRoute(refreshToken?: string) {
+        return await this.apiClient.post(`${AUTH_SDK_ROOT_ENDPOINT}/logout`, {
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                refresh: refreshToken,
+            }),
+        });
+    }
+
+    static defaultApiClient(crossmint: Crossmint): CrossmintApiClient {
+        return new CrossmintApiClient(crossmint, {
+            internalConfig: {
+                sdkMetadata: {
+                    name: SDK_NAME,
+                    version: SDK_VERSION,
+                },
+            },
+        });
+    }
+}

package/src/index.ts

@@ -1,3 +1,3 @@
-export * from "./services";
 export * from "./utils";
 export * from "./types";
+export * from "./CrossmintAuth";

package/src/types/cookies.ts

@@ -1,5 +1,13 @@
-export type CookieOptions = {
+export type CookieData = {
     name: string;
     value: string;
+    options?: CookieOptions;
+};
+
+export type CookieOptions = {
     expiresAt?: string;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: "Lax" | "Strict" | "None";
+    domain?: string;
 };

package/src/utils/constants.ts

@@ -1,3 +1,9 @@
-export const AUTH_SERVICE = "AUTH_SDK";
+import { version, name } from "../../package.json";
+
+export const SDK_VERSION = version;
+export const SDK_NAME = name;
+export const CROSSMINT_API_VERSION = "2024-09-26";
+export const AUTH_SDK_ROOT_ENDPOINT = `api/${CROSSMINT_API_VERSION}/session/sdk/auth`;
+
 export const SESSION_PREFIX = "crossmint-jwt";
 export const REFRESH_TOKEN_PREFIX = "crossmint-refresh-token";

package/src/services/CrossmintAuthService.ts

@@ -1,40 +0,0 @@
-import { APIErrorService, BaseCrossmintService } from "@crossmint/client-sdk-base";
-
-import { authLogger } from "./logger";
-import type { AuthMaterialWithUser } from "@/types";
-
-export class CrossmintAuthService extends BaseCrossmintService {
-    protected apiErrorService = new APIErrorService<never>({});
-    protected logger = authLogger;
-
-    public getJWKSUri() {
-        return `${this.crossmintBaseUrl}/.well-known/jwks.json`;
-    }
-
-    async refreshAuthMaterial(refreshToken: string): Promise<AuthMaterialWithUser> {
-        const result = await this.fetchCrossmintAPI(
-            "2024-09-26/session/sdk/auth/refresh",
-            { method: "POST", body: JSON.stringify({ refresh: refreshToken }) },
-            "Error fetching new refresh and access tokans."
-        );
-
-        return {
-            jwt: result.jwt,
-            refreshToken: result.refresh,
-            user: result.user,
-        };
-    }
-
-    async getUserFromServer(externalUserId: string) {
-        const result = await this.fetchCrossmintAPI(
-            `sdk/auth/user/${externalUserId}`,
-            { method: "GET" },
-            "Error fetching user."
-        );
-
-        return result.user;
-    }
-    async getUserFromClient(jwt: string) {
-        return await this.fetchCrossmintAPI("sdk/auth/user", { method: "GET" }, "Error fetching user.", jwt);
-    }
-}

package/src/services/index.ts

@@ -1,2 +0,0 @@
-export * from "./CrossmintAuthService";
-export * from "./logger";

package/src/services/logger.ts

@@ -1,5 +0,0 @@
-import { SDKLogger } from "@crossmint/client-sdk-base";
-
-import { AUTH_SERVICE } from "../utils/constants";
-
-export const authLogger = new SDKLogger(AUTH_SERVICE);