@arcote.tech/arc-auth 0.8.0 → 0.8.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-auth",
   "type": "module",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "private": false,
   "description": "Reusable authentication module for Arc framework — aggregate-based auth with factory pattern",
   "main": "./src/index.ts",
@@ -10,8 +10,8 @@
     "type-check": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.8.0",
-    "@arcote.tech/platform": "^0.8.0",
+    "@arcote.tech/arc": "^0.8.2",
+    "@arcote.tech/platform": "^0.8.2",
     "react": "^18.0.0 || ^19.0.0",
     "typescript": "^5.0.0"
   },

package/src/index.ts

@@ -25,7 +25,14 @@ export type {
 } from "./providers/types";
 
 // React components
-export { AuthProvider, ProtectedRoute, SignInPage, useAuth } from "./react";
+export {
+  AuthProvider,
+  ProtectedRoute,
+  SignInPage,
+  useAuth,
+  decodeTokenName,
+  isAppToken,
+} from "./react";
 export type {
   AuthContextType,
   AuthProviderProps,

package/src/react/auth-provider.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Testy granicy adopcji tokenu przez AuthProvider.
+ *
+ * Regresja bezpieczeństwa: token o innym przeznaczeniu (np. publiczny token
+ * lead/intake, który dzieli parametr URL `?token=`) NIE może zostać przyjęty
+ * jako token sesji aplikacji. Jedynym rozróżnieniem jest `tokenName` w payloadzie
+ * JWT — `isAppToken` musi go egzekwować, gdy podano oczekiwaną nazwę.
+ *
+ * Uruchomienie:
+ *   bun test packages/fragments/auth/src/react/auth-provider.test.ts
+ */
+
+import { describe, expect, it } from "bun:test";
+import { string, token } from "@arcote.tech/arc";
+import { decodeTokenName, isAppToken } from "./auth-provider";
+
+// Ten sam sekret dla obu tokenów — odwzorowuje produkcyjny fallback
+// intakeSecret → USER_TOKEN_SECRET. Granica NIE może zależeć od sekretu.
+const SECRET = "test-secret";
+
+const appToken = token("userAccount", {
+  accountId: string(),
+  role: string(),
+}).secret(SECRET);
+
+const intakeToken = token("leadIntake", {
+  leadId: string(),
+}).secret(SECRET);
+
+describe("decodeTokenName", () => {
+  it("czyta tokenName z payloadu JWT", async () => {
+    const jwt = await appToken.generateJWT({ accountId: "a1", role: "user" });
+    expect(decodeTokenName(jwt)).toBe("userAccount");
+
+    const lead = await intakeToken.generateJWT({ leadId: "lead-1" });
+    expect(decodeTokenName(lead)).toBe("leadIntake");
+  });
+
+  it("zwraca null dla wejścia niebędącego JWT", () => {
+    expect(decodeTokenName("")).toBeNull();
+    expect(decodeTokenName("not-a-jwt")).toBeNull();
+    expect(decodeTokenName("a.b")).toBeNull();
+    expect(decodeTokenName("a.%%%.c")).toBeNull();
+  });
+});
+
+describe("isAppToken", () => {
+  it("token lead/intake NIE jest tokenem aplikacji (mimo wspólnego sekretu)", async () => {
+    const lead = await intakeToken.generateJWT({ leadId: "lead-1" });
+    expect(isAppToken(lead, "userAccount")).toBe(false);
+  });
+
+  it("token userAccount jest tokenem aplikacji", async () => {
+    const jwt = await appToken.generateJWT({ accountId: "a1", role: "user" });
+    expect(isAppToken(jwt, "userAccount")).toBe(true);
+  });
+
+  it("pusty/nullowy token nigdy nie jest tokenem aplikacji", () => {
+    expect(isAppToken(null, "userAccount")).toBe(false);
+    expect(isAppToken(undefined, "userAccount")).toBe(false);
+    expect(isAppToken("", "userAccount")).toBe(false);
+  });
+
+  it("bez oczekiwanej nazwy zachowuje zgodność wsteczną (każdy niepusty token przechodzi)", async () => {
+    const lead = await intakeToken.generateJWT({ leadId: "lead-1" });
+    expect(isAppToken(lead)).toBe(true);
+    expect(isAppToken(null)).toBe(false);
+  });
+});

package/src/react/auth-provider.tsx

@@ -18,6 +18,41 @@ export interface AuthContextType {
 
 const AuthContext = createContext<AuthContextType | null>(null);
 
+/**
+ * Odczytuje `tokenName` z payloadu JWT BEZ weryfikacji podpisu — wyłącznie do
+ * decyzji „czy ten token w ogóle należy do tej aplikacji?" zanim zostanie
+ * przyjęty jako sesja. Serwer i tak weryfikuje podpis przy każdym żądaniu.
+ * Zwraca `null` dla niepoprawnego wejścia.
+ */
+export function decodeTokenName(jwt: string): string | null {
+  try {
+    const seg = jwt.split(".")[1];
+    if (!seg) return null;
+    const json = JSON.parse(
+      atob(seg.replace(/-/g, "+").replace(/_/g, "/")),
+    );
+    return typeof json?.tokenName === "string" ? json.tokenName : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Czy aplikacja powinna PRZYJĄĆ `jwt` jako swój token sesji. Gdy podano
+ * `expectedTokenName`, `tokenName` tokenu MUSI się zgadzać — to blokuje
+ * promocję tokenu o innym przeznaczeniu (np. publicznego tokenu lead/intake,
+ * który dzieli parametr URL `?token=`) do sesji aplikacji. Bez oczekiwanej
+ * nazwy przyjmowany jest każdy niepusty token (zgodność wsteczna).
+ */
+export function isAppToken(
+  jwt: string | null | undefined,
+  expectedTokenName?: string,
+): jwt is string {
+  if (!jwt) return false;
+  if (!expectedTokenName) return true;
+  return decodeTokenName(jwt) === expectedTokenName;
+}
+
 export interface AuthProviderProps {
   children: ReactNode;
   /** Callback to set token on the arc model (scope.setToken from reactModel).
@@ -26,17 +61,39 @@ export interface AuthProviderProps {
   onTokenChange?: (token: string | null) => void | Promise<void>;
   /** Initial token from scope (loaded by adapter.loadPersisted on model init) */
   initialToken?: string | null;
+  /** Oczekiwana `tokenName` tokenu APLIKACJI (np. "userAccount"). Gdy podana,
+   *  AuthProvider przyjmie token z URL/scope TYLKO jeśli jego `tokenName` się
+   *  zgadza — token o innym przeznaczeniu (lead/intake, permit) NIE zaloguje do
+   *  aplikacji, nawet jeśli trafi do parametru `?token=`. Niepasujący `?token=`
+   *  jest ignorowany (nie usuwamy go z URL — mogą go czytać inne przepływy,
+   *  np. publiczny kreator prospekta). */
+  expectedTokenName?: string;
 }
 
-export function AuthProvider({ children, onTokenChange, initialToken }: AuthProviderProps) {
-  const [token, setToken] = useState<string | null>(initialToken ?? null);
+export function AuthProvider({
+  children,
+  onTokenChange,
+  initialToken,
+  expectedTokenName,
+}: AuthProviderProps) {
+  // Nie przyjmuj przekazanego initialToken, jeśli nie jest tokenem TEJ aplikacji
+  // (samonaprawa zatrutej sesji: gdy w scope usera osiadł token o innym
+  // przeznaczeniu). `isAppToken` bez expectedTokenName jest przezroczyste.
+  const [token, setToken] = useState<string | null>(
+    isAppToken(initialToken, expectedTokenName) ? initialToken! : null,
+  );
   const [isLoading, setIsLoading] = useState(true);
 
   useEffect(() => {
     // Check for token in URL (OAuth callback redirect)
     const params = new URLSearchParams(window.location.search);
     const urlToken = params.get("token");
-    if (urlToken) {
+    // Przyjmij z URL TYLKO token aplikacji. Token o innym przeznaczeniu (np.
+    // publiczny lead/intake, który dzieli parametr `?token=`) zostaje
+    // zignorowany i NIE jest usuwany z URL — publiczne przepływy czytają go
+    // dalej. Bez tego dowolny podpisany token promowałby gościa do sesji
+    // aplikacji (`isAuthenticated` = true) mimo braku uprawnień.
+    if (urlToken && isAppToken(urlToken, expectedTokenName)) {
       // Gdy jest warstwa persystencji (scope.setToken → localStorage), utrwal
       // token i przeładuj CZYSTY URL. Hot-swap tokenu w miejscu ścigał się z
       // asynchronicznym syncModules/setActiveModules — `useQuery` (np. getMe)
@@ -62,8 +119,8 @@ export function AuthProvider({ children, onTokenChange, initialToken }: AuthProv
     }
 
     // Token loaded by adapter.loadPersisted() on model init → initialToken
-    if (initialToken) {
-      onTokenChange?.(initialToken);
+    if (isAppToken(initialToken, expectedTokenName)) {
+      onTokenChange?.(initialToken!);
     }
     setIsLoading(false);
   }, []);

package/src/react/index.ts

@@ -1,4 +1,4 @@
-export { AuthProvider, useAuth } from "./auth-provider";
+export { AuthProvider, useAuth, decodeTokenName, isAppToken } from "./auth-provider";
 export type { AuthContextType, AuthProviderProps } from "./auth-provider";
 
 export { ProtectedRoute } from "./protected-route";