@arcote.tech/arc-auth 0.7.23 → 0.7.25

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-auth",
   "type": "module",
-  "version": "0.7.23",
+  "version": "0.7.25",
   "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.7.23",
-    "@arcote.tech/platform": "^0.7.23",
+    "@arcote.tech/arc": "^0.7.25",
+    "@arcote.tech/platform": "^0.7.25",
     "react": "^18.0.0 || ^19.0.0",
     "typescript": "^5.0.0"
   },

package/src/aggregates/account.ts

@@ -1,15 +1,26 @@
 /// <reference path="../arc.d.ts" />
 import {
   aggregate,
+  array,
   boolean,
   date,
   mergeUnsafe,
+  number,
   string,
   stringEnum,
   type ArcRawShape,
 } from "@arcote.tech/arc";
 import type { AccountId } from "../ids/account";
 import type { Token } from "../tokens/token";
+import { validatePassword } from "../utils/password-policy";
+
+/**
+ * Blokada konta przy brute-force — standard bezpieczeństwa frameworku. Po
+ * `MAX_FAILED_ATTEMPTS` nieudanych logowaniach konto jest czasowo zablokowane
+ * na `LOCK_MS`; udane logowanie resetuje licznik.
+ */
+const MAX_FAILED_ATTEMPTS = 5;
+const LOCK_MS = 15 * 60_000; // 15 minut
 
 /**
  * Password helpers — server-only, tree-shaken on client.
@@ -71,6 +82,9 @@ export const createAccountAggregate = <
           authMethod: string(),
           registeredAt: date(),
           lastSignedInAt: date().optional(),
+          // Brute-force lockout — licznik nieudanych logowań + czasowa blokada.
+          failedLoginCount: number(),
+          lockedUntil: date().optional(),
         },
         customFields,
       ),
@@ -97,6 +111,7 @@ export const createAccountAggregate = <
             authMethod: "email",
             registeredAt: event.createdAt,
             lastSignedInAt: undefined,
+            failedLoginCount: 0,
             ...event.payload,
           });
         },
@@ -120,6 +135,7 @@ export const createAccountAggregate = <
             authMethod: "oauth",
             registeredAt: event.createdAt,
             lastSignedInAt: event.createdAt,
+            failedLoginCount: 0,
             ...event.payload,
           });
         },
@@ -129,8 +145,26 @@ export const createAccountAggregate = <
         "signedIn",
         { accountId, email: string().email() },
         async (ctx, event) => {
+          // Udane logowanie resetuje licznik blokady.
           await ctx.modify(event.payload.accountId, {
             lastSignedInAt: event.createdAt,
+            failedLoginCount: 0,
+            lockedUntil: undefined,
+          });
+        },
+      )
+
+      .publicEvent(
+        "loginAttemptFailed",
+        {
+          accountId,
+          failedLoginCount: number(),
+          lockedUntil: date().optional(),
+        },
+        async (ctx, event) => {
+          await ctx.modify(event.payload.accountId, {
+            failedLoginCount: event.payload.failedLoginCount,
+            lockedUntil: event.payload.lockedUntil,
           });
         },
       )
@@ -149,7 +183,10 @@ export const createAccountAggregate = <
             mergeUnsafe(
               {
                 email: string().email(),
-                password: string().minLength(6).maxLength(32),
+                // Twardy limit bcrypt 72 bajty; właściwa polityka (≥8 + złożoność)
+                // egzekwowana przez `validatePassword` w handlerze (jedno źródło
+                // prawdy z checklistą klienta).
+                password: string().minLength(1).maxLength(72),
               },
               customFields,
             ),
@@ -157,14 +194,19 @@ export const createAccountAggregate = <
           .withResult(
             { accountId, token: string() },
             {
-              error: stringEnum("EMAIL_ALREADY_TAKEN"),
-              accountId,
-              token: string(),
+              error: stringEnum("EMAIL_ALREADY_TAKEN", "WEAK_PASSWORD"),
+              accountId: accountId.optional(),
+              token: string().optional(),
             },
           )
           .handle(
             ONLY_SERVER &&
               (async (ctx, params) => {
+                const policy = validatePassword(params.password);
+                if (!policy.ok) {
+                  return { error: "WEAK_PASSWORD" as const };
+                }
+
                 const existing = await ctx.$query.findOne({
                   email: params.email,
                 });
@@ -199,8 +241,16 @@ export const createAccountAggregate = <
         fn
           .withParams({
             email: string().email(),
-            password: string().minLength(6).maxLength(32),
+            password: string().minLength(1).maxLength(72),
           })
+          .withResult(
+            { token: string() },
+            {
+              error: stringEnum("INVALID_EMAIL_OR_PASSWORD", "ACCOUNT_LOCKED"),
+              /** ISO timestamp do kiedy konto zablokowane (dla ACCOUNT_LOCKED). */
+              lockedUntil: string().optional(),
+            },
+          )
           .handle(
             ONLY_SERVER &&
               (async (ctx, params) => {
@@ -212,11 +262,41 @@ export const createAccountAggregate = <
                   return { error: "INVALID_EMAIL_OR_PASSWORD" as const };
                 }
 
+                // Blokada czasowa — odrzuć przed weryfikacją hasła.
+                const now = Date.now();
+                if (
+                  account.lockedUntil &&
+                  new Date(account.lockedUntil).getTime() > now
+                ) {
+                  return {
+                    error: "ACCOUNT_LOCKED" as const,
+                    lockedUntil: new Date(account.lockedUntil).toISOString(),
+                  };
+                }
+
                 const isValid = await verifyPassword(
                   params.password,
                   account.passwordHash!,
                 );
                 if (!isValid) {
+                  const attempts = (account.failedLoginCount ?? 0) + 1;
+                  const shouldLock = attempts >= MAX_FAILED_ATTEMPTS;
+                  const lockedUntil = shouldLock
+                    ? new Date(now + LOCK_MS)
+                    : undefined;
+                  await ctx.loginAttemptFailed.emit({
+                    accountId: account._id,
+                    // Po zablokowaniu zerujemy licznik — po wygaśnięciu blokady
+                    // użytkownik dostaje świeżą pulę prób.
+                    failedLoginCount: shouldLock ? 0 : attempts,
+                    lockedUntil,
+                  });
+                  if (shouldLock) {
+                    return {
+                      error: "ACCOUNT_LOCKED" as const,
+                      lockedUntil: lockedUntil!.toISOString(),
+                    };
+                  }
                   return { error: "INVALID_EMAIL_OR_PASSWORD" as const };
                 }
 

package/src/auth-builder.ts

@@ -12,6 +12,7 @@ import { createAccountId } from "./ids/account";
 import { createOAuthIdentityId } from "./ids/oauth-identity";
 import { createToken } from "./tokens/token";
 import { createOAuthRoutes } from "./routes/oauth-routes";
+import { createLogoutRoute } from "./routes/logout-route";
 import type { AccountId } from "./ids/account";
 import type { OAuthProvidersConfig } from "./providers/types";
 import type { Token } from "./tokens/token";
@@ -86,8 +87,10 @@ export class AuthBuilder<
   }
 
   build() {
+    // Logout route zawsze obecny (niezależnie od OAuth) — czyści cookie sesji.
+    const logout = createLogoutRoute();
     return {
-      context: context(this.elements),
+      context: context([...this.elements, logout]),
       accountId: this.accountId,
       token: this.token,
       Account: this.Account,

package/src/index.ts

@@ -13,6 +13,10 @@ export type { OAuthIdentityId } from "./ids/oauth-identity";
 export { createToken } from "./tokens/token";
 export type { Token } from "./tokens/token";
 
+// Polityka haseł — jedno źródło prawdy dla checklisty klienta i walidacji serwerowej
+export { validatePassword, passwordRequirements } from "./utils/password-policy";
+export type { PasswordRule, PasswordValidation } from "./utils/password-policy";
+
 // Provider types
 export type {
   OAuthProviderConfig,

package/src/react/auth-provider.tsx

@@ -13,7 +13,7 @@ export interface AuthContextType {
   /** Resolves when the module loader has synced chunks for the new token —
    *  await before navigating to a token-gated route. */
   setAccessToken: (token: string) => Promise<void>;
-  logout: () => void;
+  logout: () => Promise<void>;
 }
 
 const AuthContext = createContext<AuthContextType | null>(null);
@@ -60,7 +60,19 @@ export function AuthProvider({ children, onTokenChange, initialToken }: AuthProv
     await onTokenChange?.(newToken);
   };
 
-  const logout = () => {
+  const logout = async (): Promise<void> => {
+    // Najpierw serwerowo wygaś cookie `arc_token` (HttpOnly — JS go nie ruszy);
+    // bez tego serwer używałby go jako fallback (m.in. upgrade /ws) i sesja
+    // trwałaby po wylogowaniu. Best-effort: błąd sieci nie blokuje czyszczenia
+    // stanu klienta, żeby UI był wylogowany.
+    try {
+      await fetch("/route/auth/logout", {
+        method: "POST",
+        credentials: "include",
+      });
+    } catch {
+      /* offline / serwer niedostępny — i tak czyścimy stan lokalny */
+    }
     setToken(null);
     onTokenChange?.(null); // scope.setToken(null) → adapter clears this scope
   };

package/src/routes/logout-route.ts

@@ -0,0 +1,28 @@
+import { route } from "@arcote.tech/arc";
+
+/**
+ * Publiczny route wylogowania — wygasza serwerowe cookie sesji `arc_token`
+ * (ustawiane przez OAuth callback, Max-Age 7 dni). Symetryczny do logowania:
+ * skoro OAuth ustawia cookie, logout musi je czyścić serwerowo — JS nie ruszy
+ * HttpOnly cookie, a serwer używa go jako fallback dla każdego requestu (w tym
+ * upgrade'u `/ws`), więc bez tego po wylogowaniu sesja trwała dalej.
+ *
+ * Publiczny (logout nie może wymagać auth). Czyszczenie nieistniejącego cookie
+ * (login hasłem) jest no-opem. Atrybuty muszą pokrywać się z ustawieniem
+ * (Path=/) żeby przeglądarka dopasowała cookie do usunięcia.
+ */
+export function createLogoutRoute() {
+  return route("authLogout")
+    .path("/auth/logout")
+    .public()
+    .handle({
+      POST: async () => {
+        const headers = new Headers();
+        headers.append(
+          "Set-Cookie",
+          "arc_token=; HttpOnly; SameSite=Lax; Path=/; Max-Age=0",
+        );
+        return new Response(null, { status: 204, headers });
+      },
+    });
+}

package/src/utils/password-policy.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "bun:test";
+import { validatePassword } from "./password-policy";
+
+describe("validatePassword", () => {
+  it("akceptuje hasło spełniające wszystkie reguły (cyfra)", () => {
+    expect(validatePassword("Haslo123")).toEqual({ ok: true, failed: [] });
+  });
+
+  it("akceptuje wariant ze znakiem specjalnym zamiast cyfry", () => {
+    expect(validatePassword("Haslo!ab")).toEqual({ ok: true, failed: [] });
+  });
+
+  it("za krótkie → failed length", () => {
+    expect(validatePassword("Ab1")).toEqual({ ok: false, failed: ["length"] });
+  });
+
+  it("brak wielkiej litery", () => {
+    const r = validatePassword("haslo123");
+    expect(r.ok).toBe(false);
+    expect(r.failed).toContain("uppercase");
+  });
+
+  it("brak małej litery", () => {
+    const r = validatePassword("HASLO123");
+    expect(r.ok).toBe(false);
+    expect(r.failed).toContain("lowercase");
+  });
+
+  it("brak cyfry i znaku specjalnego", () => {
+    const r = validatePassword("HasloAbcd");
+    expect(r.ok).toBe(false);
+    expect(r.failed).toContain("digitOrSymbol");
+  });
+
+  it("puste hasło → wszystkie reguły poza znakiem", () => {
+    const r = validatePassword("");
+    expect(r.ok).toBe(false);
+    expect(r.failed).toEqual(["length", "lowercase", "uppercase", "digitOrSymbol"]);
+  });
+});

package/src/utils/password-policy.ts

@@ -0,0 +1,33 @@
+/**
+ * Polityka haseł — jedno źródło prawdy dla walidacji serwerowej (`register`) i
+ * checklisty po stronie klienta. Reguły są language-neutralne (`key` + `test`);
+ * etykiety (i18n) dostarcza konsument, mapując po `key`.
+ *
+ * Standard: ≥8 znaków, mała litera, wielka litera, oraz cyfra LUB znak specjalny.
+ */
+export interface PasswordRule {
+  /** Stabilny klucz reguły — konsument mapuje go na etykietę (i18n). */
+  key: "length" | "lowercase" | "uppercase" | "digitOrSymbol";
+  test: (password: string) => boolean;
+}
+
+export const passwordRequirements: readonly PasswordRule[] = [
+  { key: "length", test: (p) => p.length >= 8 },
+  { key: "lowercase", test: (p) => /[a-z]/.test(p) },
+  { key: "uppercase", test: (p) => /[A-Z]/.test(p) },
+  { key: "digitOrSymbol", test: (p) => /[0-9]/.test(p) || /[^A-Za-z0-9]/.test(p) },
+];
+
+export interface PasswordValidation {
+  ok: boolean;
+  /** Klucze reguł, które NIE są spełnione. */
+  failed: PasswordRule["key"][];
+}
+
+/** Waliduje hasło względem polityki. `ok` gdy wszystkie reguły spełnione. */
+export function validatePassword(password: string): PasswordValidation {
+  const failed = passwordRequirements
+    .filter((r) => !r.test(password))
+    .map((r) => r.key);
+  return { ok: failed.length === 0, failed };
+}