Auth Projects

Hızlı karar: Kullanıcılarınızın zaten Sentroy hesabıyla giriş yapmasını istiyorsanız (örn. iç araç) → Sign in with Sentroy. Kendi kullanıcı havuzunuzu sıfırdan host etmek istiyorsanız (consumer ürün, multi-tenant SaaS) → Auth Project, bu sayfa.

1. auth.sentroy.com'a login olup Auth Projects sidebar entry'sinden yeni proje oluşturun. Wizard sizi şu adımlardan geçirir:

• Name + Slug — slug public URL'lerde geçer (auth.sentroy.com/p/<slug>), sonradan değişmez.
• Branding — primary color + display name + logo URL. Mail template'i, verify-email / reset-password / login / signup landing page'lerinde marka kimliğiniz olur.
• Email verification — açıkken signup sonrası kullanıcı mail link tıklamadan login yapamaz.
• Magic link — passwordless login akışı.
• Allowed origins (CORS) — browser'dan public auth API'yi çağıracak origin'leriniz. Boş bırakırsanız yalnız server-to-server kullanım (browser CORS reddedilir).
• Social providers — Google / GitHub / Facebook / Microsoft / X / Apple credentials (her biri opsiyonel). Tetiklendiğinde Sentroy-hosted authorize URL üretilir.

Create response'unda plaintext API key (aps_...) bir kez gösterilir — RP backend'inizin env'ine kopyalayın (örn. SENTROY_AUTH_API_KEY). DB'de hash'i kalır, plaintext'i geri alamazsınız; sızdırılırsa dashboard'dan rotate edin.

npm: npm install @sentroy-co/client-sdk (v2.13.9+ — auth modülü dahil)

Passkey desteği isterseniz opsiyonel peer dep: npm install @simplewebauthn/browser

// app/lib/sentroy-auth.ts
import { SentroyAuth } from "@sentroy-co/client-sdk/auth"

export const auth = new SentroyAuth({
  projectSlug: "acme-app",
  apiKey: process.env.NEXT_PUBLIC_SENTROY_AUTH_API_KEY!,
  storage: "localStorage", // "memory" | "localStorage" | custom adapter
})

// Firebase tarzı subscription
auth.onAuthStateChanged((user) => {
  console.log(user ? "signed in: " + user.email : "signed out")
})

// Signup — emailVerification açıksa tokens dönmez, mail gönderilir
await auth.signUp({ email: "alice@example.com", password: "hunter2-strong" })

// Login — MFA-aware discriminated union
const out = await auth.signIn({
  email: "alice@example.com",
  password: "hunter2-strong",
  rememberMe: true, // refresh token TTL'i uzar (30g → 90g)
})

if (out.kind === "mfa") {
  // Kullanıcıdan TOTP code veya recovery code iste
  const code = prompt("MFA code")
  await auth.verifyMfa({ mfaToken: out.data.mfaToken, code })
} else {
  // out.data.user, out.data.accessToken hazır
  console.log("logged in:", out.data.user)
}

await auth.signOut()

SentroyAuthProvider tek bir SDK instance tutar; tüm hook'lar onun üzerinden çalışır. Provider mount'ta storage'dan restore + (varsa) social-login fragment'ı consume eder.

"use client"
import { useAuth, useSessions, useMfa, usePasskeys } from "@sentroy-co/client-sdk/auth/react"

export function SecurityPage() {
  const { user } = useAuth()
  const { sessions, revoke } = useSessions()
  const { status, enrollTotp, verifyTotpEnrollment, disableTotp } = useMfa()
  const { passkeys, register, remove } = usePasskeys()

  return (
    <div>
      <h2>Active sessions</h2>
      {sessions?.map((s) => (
        <div key={s.id}>
          {s.userAgent} · {s.ip}
          <button onClick={() => revoke(s.id)}>Revoke</button>
        </div>
      ))}

      <h2>Two-factor auth</h2>
      {status?.enrolled ? (
        <button onClick={() => disableTotp(currentPassword)}>Disable TOTP</button>
      ) : (
        <button onClick={async () => {
          const { secret, otpauthUri } = await enrollTotp()
          // QR code'u otpauthUri'den render et, kullanıcı 6-digit girip:
          await verifyTotpEnrollment(code)
        }}>Enroll TOTP</button>
      )}

      <h2>Passkeys</h2>
      <button onClick={() => register("MacBook Touch ID")}>Add passkey</button>
      {passkeys?.map((p) => (
        <div key={p.id}>
          {p.deviceName} <button onClick={() => remove(p.id)}>Remove</button>
        </div>
      ))}
    </div>
  )
}

SDK platform-agnostic core ile build edilir; React Native'delocalStorage yoktur, bu yüzden storage adapter verilmelidir. İki yaygın seçenek: AsyncStorage (hızlı, encrypted değil) veya SecureStore (iOS Keychain / Android Keystore — refresh token gibi long-lived sırlar için önerilir). Sosyal login için expo-web-browser kullanılır (in-app browser session).

Install: expo install @react-native-async-storage/async-storage expo-secure-store expo-web-browser

// app/lib/sentroy-auth.ts
import AsyncStorage from "@react-native-async-storage/async-storage"
import { SentroyAuth, type SentroyAuthStorage } from "@sentroy-co/client-sdk/auth"

function createAsyncStorageAdapter(): SentroyAuthStorage {
  return {
    getItem: (key) => AsyncStorage.getItem(key),
    setItem: (key, value) => AsyncStorage.setItem(key, value),
    removeItem: (key) => AsyncStorage.removeItem(key),
  }
}

export const auth = new SentroyAuth({
  projectSlug: "acme-app",
  apiKey: process.env.EXPO_PUBLIC_SENTROY_AUTH_API_KEY!,
  storage: createAsyncStorageAdapter(),
})

// Aynı SDK API — tüm signIn/signUp/onAuthStateChanged Web'le birebir:
auth.onAuthStateChanged((user) => {
  console.log(user ? "signed in " + user.email : "signed out")
})

// app.config.ts
export default {
  expo: {
    name: "Acme",
    slug: "acme-app",
    scheme: "myapp", // <-- bu sayede myapp://... URL'leri app'e açılır
    ios: { bundleIdentifier: "com.acme.app" },
    android: { package: "com.acme.app" },
  },
}

// app/App.tsx
import { SentroyAuthProvider, useAuth } from "@sentroy-co/client-sdk/auth/react"
import { ActivityIndicator, View } from "react-native"
import { auth } from "./lib/sentroy-auth"

function Root() {
  const { user, loading } = useAuth()

  if (loading) {
    // Storage henüz rehydrate olmadı — splash göster
    return (
      <View style={{ flex: 1, justifyContent: "center", alignItems: "center" }}>
        <ActivityIndicator />
      </View>
    )
  }

  return user ? <HomeStack /> : <AuthStack />
}

export default function App() {
  return (
    <SentroyAuthProvider client={auth}>
      <Root />
    </SentroyAuthProvider>
  )
}

SDK kullanım API'si tüm framework'lerde aynı; değişen tek şey provider'ı app shell'ine nasıl wrap ettiğin. Aşağıdaki recipe'ler en hızlı yolu gösterir.

// app/providers.tsx — Provider client component
"use client"
import { SentroyAuthProvider } from "@sentroy-co/client-sdk/auth/react"

export function Providers({ children }: { children: React.ReactNode }) {
  return (
    <SentroyAuthProvider
      projectSlug="acme-app"
      apiKey={process.env.NEXT_PUBLIC_SENTROY_AUTH_API_KEY!}
      autoConsumeFragment
    >
      {children}
    </SentroyAuthProvider>
  )
}

// app/layout.tsx — Server component wraps Providers
import { Providers } from "./providers"
export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <body>
        <Providers>{children}</Providers>
      </body>
    </html>
  )
}

// app/account/page.tsx — useAuth in any client component
"use client"
import { useAuth } from "@sentroy-co/client-sdk/auth/react"
export default function Account() {
  const { user, loading, signOut } = useAuth()
  if (loading) return <p>Loading…</p>
  if (!user) return <a href="/login">Sign in</a>
  return <button onClick={() => signOut()}>Sign out {user.email}</button>
}

Her provider için RP kendi OAuth client'ını dashboard'da tanımlar (clientId + secret; Apple için teamId/keyId/p8 privateKey). Sentroy callback URL'i her provider için sabit: https://auth.sentroy.com/api/v1/auth/<slug>/social/<provider>/callback

// SDK helper: redirect URL üret
import { useAuth } from "@sentroy-co/client-sdk/auth/react"

function SocialButtons() {
  const { socialAuthorizeUrl } = useAuth()
  const go = (provider: "google" | "github" | "apple") => {
    window.location.href = socialAuthorizeUrl(provider, {
      redirectUri: window.location.origin + "/auth/callback",
      rememberMe: true,
    })
  }
  return (
    <>
      <button onClick={() => go("google")}>Continue with Google</button>
      <button onClick={() => go("github")}>Continue with GitHub</button>
      <button onClick={() => go("apple")}>Continue with Apple</button>
    </>
  )
}

// Callback page — Sentroy fragment'ta access_token+refresh_token döndürür
// SentroyAuthProvider autoConsumeFragment=true ile otomatik consume eder.
// Manual: await auth.consumeRedirectFragment()

# Browser bu URL'e GET ile yönlendirilir (apiKey gerektirmez)
GET https://auth.sentroy.com/api/v1/auth/acme-app/social/google/authorize?
  redirectUri=https://app.example.com/auth/callback&
  rememberMe=1

# Sentroy provider'a redirect → callback'i kendisi handle eder →
# user'ı redirectUri'ye gönderir, fragment:
#   #access_token=eyJ...&refresh_token=apt_...&token_type=Bearer&expires_in=3600

Project ayarında magicLinkEnabled: trueolması gerekir. Email enumeration koruması: request her zaman 200 döner (hesap yoksa mail gitmez).

// 1. Login form yerine — magic link iste
await auth.sendMagicLink({
  email: "alice@example.com",
  redirectUri: "https://app.example.com/welcome",
})

// 2. Mail link: https://auth.sentroy.com/p/acme-app/magic?token=...
//    Sentroy-hosted page consume eder VEYA RP kendi page'inde:

// 3. RP'nin /auth/magic callback page'i:
const tokenFromUrl = new URLSearchParams(location.search).get("token")!
const { user } = await auth.consumeMagicLink(tokenFromUrl)
// → session kuruldu, user state güncellendi

Akış: enrollTotp() → verifyTotpEnrollment(code) → kullanıcının next login'inde signIn kind: "mfa" döner → verifyMfa({ mfaToken, code }).

// 1. Enrollment — kullanıcı Authenticator app'ine QR'ı ekler
const { secret, otpauthUri } = await auth.mfa.enrollTotp()
// otpauthUri = "otpauth://totp/Acme:alice@example.com?secret=...&issuer=Acme"
// Bunu QR code component'ine ver, kullanıcı taradıktan sonra:

// 2. Enrollment confirm — 6-digit code'la
const { recoveryCodes } = await auth.mfa.verifyTotpEnrollment("123456")
// recoveryCodes: 10 tane one-time-use code — kullanıcıya GÖSTER ve indir/sakla de
// (forgot-totp akışında bu kodlardan biri ile recovery sign-in yapılır)

// 3. Sonraki login akışı — discriminated union
const out = await auth.signIn({ email, password })
if (out.kind === "mfa") {
  const code = prompt("6-digit code")
  await auth.verifyMfa({ mfaToken: out.data.mfaToken, code })
  // veya: await auth.verifyMfa({ mfaToken, recoveryCode: "..." })
}

// Disable — current password ile re-auth
await auth.mfa.disableTotp("currentPassword")

Status check: await auth.mfa.getStatus() →{ enrolled, factorType, verifiedAt, recoveryCodesRemaining }.

İki akış: register (giriş yapmış kullanıcıya yeni passkey ekleme) ve authenticate (passkey ile sign-in).

// Kayıtlı user yeni passkey ekler
await auth.passkey.register("MacBook Touch ID")
// → browser WebAuthn prompt'u, başarılıysa passkey listesine eklenir

// List + delete
const keys = await auth.passkey.list()
// [{ id, credentialIdPrefix, deviceName, transports, lastUsedAt, createdAt }]
await auth.passkey.delete(keys[0].id)

// Passwordless sign-in
const { user } = await auth.passkey.authenticate({
  email: "alice@example.com", // opsiyonel — varsa o user'ın passkey'leri allow-listed
  rememberMe: true,
})
// → session kuruldu

React: usePasskeys() hook'u list + register + remove'u reactive sağlar (mutation sonrası otomatik refresh).

Dashboard'da Users sayfasından Invite user ile davet gönderilir. Davet alan kullanıcıya mail gider: https://auth.sentroy.com/p/<slug>/invitation?token=...(Sentroy-hosted) ya da RP kendi sayfasında consume edebilir.

// RP'nin /invitation/accept sayfası — token URL'den gelir
const token = new URLSearchParams(location.search).get("token")!

const { user } = await auth.acceptInvitation({
  token,
  password: "newPasswordChosen",
  displayName: "Alice",
})
// → hesap create + session kuruldu, redirect home'a

Server-side admin SDK ile davet üretmek için dashboard endpoint'i kullanılır (POST /api/companies/{slug}/auth-projects/{id}/invitations — cookie auth). v2'de public API katmanında aps_ ile invite create endpoint'i planlandı.

Tüm /me/* endpoint'leri kullanıcının access token'ı (user JWT) ile auth'lanır. SDK üzerinden çağrı:

// Profil + üyelik
const me = await auth.getCurrentUser()                     // canlı DB read
const sessions = await auth.listSessions()                  // active sessions
await auth.revokeSession(sessionId)                         // belirli session'ı kapat

// Şifre değiştir — tüm sessions revoke + local session clear
await auth.changePassword({ currentPassword, newPassword })

// Email değiştir — confirmation mail yeni adrese gider
await auth.requestEmailChange({ newEmail, currentPassword })
// User mail'i tıklayınca:
await auth.confirmEmailChange(tokenFromMailLink)
// → email update + tüm sessions revoke + local clear

// Hesap sil — iki adımlı (confirmation mail)
await auth.requestAccountDeletion(currentPassword)
// Mail link:
await auth.confirmAccountDeletion(tokenFromMailLink)
// → hesap hard-delete, local session clear

// Activity log — login/password-change/email-change/MFA/passkey/social events
const activity = await auth.getActivity()
// [{ id, action, ipAddress, createdAt, details }]

React: useSessions() ve useActivity() hook'larını kullanmak en temizi — mutation sonrası otomatik refresh.

Sentroy yalnızca auth için gerekli alanları saklar: id, email, emailVerified, displayName, image, locale, metadata (~16KB cap), createdAt, lastLoginAt, lastLoginIp. Aboneliğiniz, siparişleriniz, post'larınız, kullanıcı tercih JSON'unuz — bunlar sizin DB'nizde kalır ve Sentroy sub claim'i (= user.id) ile foreign-key'lenir.

// app/api/webhooks/sentroy-auth/route.ts
import { createHmac, timingSafeEqual } from "node:crypto"
import { db } from "@/lib/db"

export async function POST(req: Request) {
  const sig = req.headers.get("X-Sentroy-Signature") ?? ""
  const body = await req.text()
  const expected =
    "sha256=" +
    createHmac("sha256", process.env.SENTROY_WEBHOOK_SECRET!)
      .update(body)
      .digest("hex")
  if (sig.length !== expected.length || !timingSafeEqual(Buffer.from(sig), Buffer.from(expected))) {
    return new Response("bad signature", { status: 401 })
  }

  const event = JSON.parse(body) as
    | { event: "user.signup"; data: { userId: string; email: string } }
    | { event: "user.account-deleted"; data: { userId: string } }
    | { event: "user.email-changed"; data: { userId: string; email: string } }

  switch (event.event) {
    case "user.signup":
      await db.user.create({
        data: {
          sentroyUserId: event.data.userId,
          email: event.data.email,
          createdAt: new Date(),
        },
      })
      break
    case "user.email-changed":
      await db.user.update({
        where: { sentroyUserId: event.data.userId },
        data: { email: event.data.email },
      })
      break
    case "user.account-deleted":
      // Cascade delete — orders, posts, comments tüm FK'lar
      await db.user.delete({ where: { sentroyUserId: event.data.userId } })
      break
  }

  return new Response(null, { status: 200 })
}

// İyi kullanım
await auth.signUp({
  email: "alice@example.com",
  password: "...",
  metadata: {
    onboarded: false,           // app routes onboarding wizard'a
    plan: "trial",              // custom claim → JWT'ye kopyalanır
    invitedBy: "alice@x.com",   // attribution
    marketingOptIn: true,
  },
})

// KÖTÜ kullanım — bulk data Sentroy'a göndermeyin
await auth.updateProfile({
  metadata: {
    addressBook: [...],         // 50KB JSON — 16KB cap aşar
    sessionHistory: [...],       // append-only log Sentroy işi değil
    creditCardLast4: "4242",    // PCI scope hedefi, kendi DB'nizde tutun
  },
})

// app/api/me/export/route.ts
import { db } from "@/lib/db"
import { admin } from "@/lib/sentroy-admin"

export async function GET(req: Request) {
  const token = req.headers.get("authorization")?.replace(/^Bearer\s+/, "")
  const claims = await admin.verifyIdToken(token!)
  const sentroyMe = await admin.users.get(claims.sub) // canlı profil
  const ourRows = await db.user.findUnique({
    where: { sentroyUserId: claims.sub },
    include: { orders: true, posts: true, preferences: true },
  })

  return Response.json({
    sentroy: sentroyMe,
    application: ourRows,
    exportedAt: new Date().toISOString(),
  })
}

Her project için Sentroy şu sayfaları otomatik host eder (branding'iniz uygulanır):

RP kendi sayfasına ?redirectUri=... param ekleyerek geri yönlendirme yapar. Auth tokens fragment'ta döner (RP'nin SDK'sı consumeRedirectFragment() ile alır).

Dashboard'da Webhooks tab'ından create. Her webhook için HMAC-SHA256 secret üretilir (plaintext bir kez gösterilir). Topic'lere abone olunur veya boş bırakılırsa hepsi gönderilir.

POST https://yourapp.com/webhooks/sentroy-auth
Content-Type: application/json
User-Agent: sentroy-auth-webhook/1.0
X-Sentroy-Event: user.signup
X-Sentroy-Signature: sha256=<hex-hmac>
X-Sentroy-Delivery-Id: dlv_<random>

{
  "event": "user.signup",
  "timestamp": "2026-05-18T12:34:56.789Z",
  "data": {
    "userId": "...",
    "email": "alice@example.com",
    "emailVerified": false,
    "provider": "email" // veya "google" | "github" | ...
  }
}

import { createHmac, timingSafeEqual } from "node:crypto"

export async function POST(req: Request) {
  const sig = req.headers.get("X-Sentroy-Signature") // "sha256=..."
  const body = await req.text()
  const expected = "sha256=" + createHmac("sha256", process.env.SENTROY_WEBHOOK_SECRET!)
    .update(body)
    .digest("hex")

  const a = Buffer.from(sig ?? "")
  const b = Buffer.from(expected)
  if (a.length !== b.length || !timingSafeEqual(a, b)) {
    return new Response("bad signature", { status: 401 })
  }

  const event = JSON.parse(body)
  // ... process event.data
  return new Response(null, { status: 200 })
}

Retry: 3 attempt (0s / 2s / 10s backoff). 4xx (429 hariç) → deterministik fail, retry yok. 5xx ve network error → retry. Tüm attempt'ler auth_project_webhook_deliveries koleksiyonuna 30 gün TTL ile loglanır; dashboard'da Webhook deliveries tab'ında görülür.

Auth modes: aps_ = project API key (server-only master), user = end-user access token, none = single-use token (zaten secret).

Aşağıda 8 en sık kullanılan endpoint için TypeScript SDK / cURL / Python örnekleri. aps_ = project master API key (server-only), <access-token> = end-user JWT. Tüm path'ler https://auth.sentroy.com/api/v1/auth/<your-project-slug>/... altındadır.

import { SentroyAuth } from "@sentroy-co/client-sdk/auth"

const auth = new SentroyAuth({
  projectSlug: "acme-app",
  apiKey: process.env.SENTROY_AUTH_API_KEY!,
})

const out = await auth.signUp({
  email: "alice@example.com",
  password: "hunter2-strong",
  displayName: "Alice",
  metadata: { plan: "trial" },
})
// emailVerification açıksa: out.kind === "verification-required"
// kapalıysa: out.kind === "tokens" → out.data.accessToken hazır

const out = await auth.signIn({
  email: "alice@example.com",
  password: "hunter2-strong",
  rememberMe: true,
})

if (out.kind === "mfa") {
  const code = prompt("6-digit code from authenticator app")!
  await auth.verifyMfa({ mfaToken: out.data.mfaToken, code })
} else {
  // out.data.user, out.data.accessToken, out.data.refreshToken
  console.log("Signed in:", out.data.user.email)
}

// SDK otomatik refresh yapar — manuel çağrı gerekmez:
const me = await auth.getCurrentUser() // 401 olursa SDK içeride refresh + retry

// Manuel (custom backend için):
const { accessToken, refreshToken } = await auth.refresh(currentRefreshToken)

await auth.signOut()
// → POST /logout + local storage clear + onAuthStateChanged(null) fire

// SDK kullanıyorsan auth.getCurrentUser() yeterli (SDK shape).
// OIDC claim shape istiyorsan raw fetch:
const accessToken = auth.getAccessToken()
const resp = await fetch(
  "https://auth.sentroy.com/api/v1/auth/acme-app/userinfo",
  { headers: { Authorization: `Bearer ${accessToken}` } }
)
const claims = await resp.json()
// { sub, email, email_verified, name, picture, locale, ... }

// /verify-email landing page'inde:
const token = new URLSearchParams(location.search).get("token")!
const { user, accessToken } = await auth.verifyEmail(token)
// → emailVerified=true + signed in

// 1. Request reset
await auth.sendPasswordReset({
  email: "alice@example.com",
  redirectUri: "https://app.example.com/reset",
})
// → her zaman success (silent no-op if no account)

// 2. /reset page'inde, token URL param'dan:
const token = new URLSearchParams(location.search).get("token")!
const { user, accessToken } = await auth.confirmPasswordReset({
  token,
  newPassword: "newSecurePass123",
})

import { SentroyAuthAdmin } from "@sentroy-co/client-sdk/auth/admin"

const admin = new SentroyAuthAdmin({
  projectSlug: "acme-app",
  apiKey: process.env.SENTROY_AUTH_API_KEY!,
  jwksCacheTtl: 3600, // saniye — default 1h
})

// JWKS otomatik fetch + cache + kid match + signature verify
const claims = await admin.verifyIdToken(accessToken)
// claims.sub, claims.email, claims.iss, claims.aud, claims.exp

// Manuel JWKS pull (debugging / custom verify):
const jwks = await fetch(
  "https://auth.sentroy.com/api/v1/auth/acme-app/jwks.json"
).then((r) => r.json())
// { keys: [{ kty: "RSA", kid: "...", n: "...", e: "AQAB", alg: "RS256" }, ...] }

SDK'nın verifyIdToken() metodu JWKS'i fetch edip kid ile eşleştirir, signature + iss + aud + exp kontrol eder. JWKS cache TTL default 1 saat (rotation grace period'una uyumlu); manuel invalidation: admin.invalidateJwksCache().

{
  "sub": "auth-project-user-id",      // user id
  "email": "alice@example.com",
  "email_verified": true,
  "name": "Alice",                    // displayName
  "picture": "https://...",           // image URL
  "iss": "https://auth.sentroy.com/p/acme-app",
  "aud": "aps_a1b2c3d4e5f6",          // project API key prefix
  "iat": 1733000000,
  "exp": 1733003600,                  // 1 hour TTL

  // Eğer customClaims set'liyse:
  "plan": "pro",                      // staticClaims
  "orgId": "org_xyz"                  // fromMetadata
}

Dashboard Settings → Custom claims'ten config. İki tip:

• From metadata — whitelist top-level key'ler; user.metadata içindeki o key JWT'ye kopyalanır. Örnek: user.metadata.orgId = "org_xyz" + whitelist ["orgId"] → orgId claim'i set.
• Static claims — her user'a sabit eklenir (örn. project version tag, deployment env). aud/iss/sub override edilemez.

Update metadata: dashboard'dan user detail'inde edit, veya PATCH /api/companies/{slug}/auth-projects/{id}/users/{userId}.

Mail'ler Sentroy'un sistem mail platform'undan noreply@auth.sentroy.com üzerinden gider (v2'de custom from-domain). Default template'ler tr + en locale'lerinde. Dashboard → Emails tab'ından her template için override yazılabilir (LocalizedField — TR/EN sekme, aynı widget):

• verify-email
• password-reset
• magic-link
• invitation
• new-device-alert — lastLoginIp değişince
• account-locked — 5 failed login lockout
• email-change-confirm
• account-delete-confirm

Override yoksa Sentroy default template (project branding placeholder'ları ile render edilir). Placeholder'lar:

• {projectName} — branding.displayName
• {primaryColor} — CTA buton rengi
• {logoUrl} — logo (yoksa text fallback)
• {userEmail} — recipient address
• {verifyUrl} / {resetUrl} / {magicUrl} / {invitationUrl} — action URL'leri

Dashboard Users → Import butonuyla CSV upload edilir. Format:

# users.csv
email,passwordHash,passwordAlgo,emailVerified,displayName,metadata
alice@example.com,scrypt$N$r$p$salt$hash,scrypt,true,Alice,"{""plan"":""pro""}"
bob@example.com,$argon2id$v=19$...,argon2id,true,Bob,"{}"
carol@example.com,,,false,Carol,"{}"

# Hash yoksa: user "password reset gerekli" state'inde import edilir;
# ilk login denemesinde reset mail gider.

Desteklenen hash formatları: scrypt (native), argon2id, bcrypt (transparent migration — ilk login'de scrypt'e re-hash). Auth0/Firebase'in farklı hash formatları için adapter script'i SDK örneklerinde mevcut.

Import sırasında user.signup webhook'u tetiklenmez (bulk migration için). Tetiklenmesini istiyorsanız Trigger webhooks checkbox'ını işaretleyin.

Dashboard tab'ları: Overview (MAU + recent signups grafik), Users (paginated list, search, email-verified filter, per-user revoke/delete), Activity (audit log), Webhooks, Emails (template overrides), Settings (branding, password policy, allowed origins, custom claims, JWT key rotation, social providers, magic link toggle, email verification toggle, plan/quota),API keys.

Dashboard endpoint'leri cookie auth ile çalışır (cross-subdomain .sentroy.com). RP'nin server-to-server user yönetimi için aps_ public API kullanılır — admin endpoint'lerinin tam public API katmanı v2'de planlandı.

• Password hash: scrypt N=2^16 (OWASP minimum, pure Node — native binding gerekmez). Format self-describing: scrypt$N$r$p$salt$hash. Argon2id + bcrypt import için transparent migration.
• HaveIBeenPwned check: signup ve password-reset confirm'de yeni şifre HIBP k-anonymity API'sine query atılır (ilk 5 char hash). Breached parolalar reddedilir.
• Failed login lockout: 5 başarısız deneme sonrası account 15 dakika kilitli + account-locked webhook + mail. Lockout window kullanıcı başına; session/IP değil.
• Email enumeration: password reset, magic link request her zaman 200 döner — hesap yoksa silent no-op. Signup explicit 409 döner (DX trade-off); v2'de tightening.
• Rate limit: per-IP signup 5/dk, login 20/dk, password-reset 3/dk. Aşımda 429 + Retry-After header.
• Refresh token rotation: RFC 9700 family-based. Reuse detection → tüm family revoke + audit log (auth-project.refresh.reuse-detected). Remember-me TTL: 30g default, 90g remember-me.
• CORS: Project'in allowedOrigins listesi authoritative. Boş = browser çağrıları reddedilir (yalnız server-to-server).
• JWT signing: Per-project RSA 2048-bit keypair. Public key JWKS'te publish; private key DB'de AES-GCM şifrelenmiş, sadece sign sırasında decrypt. 2-slot rotation destekli: yeni key issue'a kullanılır, eski key grace period'da (verify-only) kalır → JWKS her ikisini publish eder.
• Social provider secret'ları: ClientSecret + Apple p8 privateKey AES-256-GCM şifreli DB'de;ENV_VAULT_MASTER_KEY ile decrypt.
• Webhook secret: Plaintext DB'de (HMAC verify için lazım) — DB compromise threat model'inde zaten her şey kompromize; ayrıca encrypt savunma derinliği vermez.
• Quota: Free tier 5K MAU + 100 signup/saat (atomic counter, signup endpoint'inde enforce). Aşımda 429. Paid tier unlimited.

• Custom domain (auth.customer.com CNAME)
• Public admin API katmanı (aps_ ile users.list/get/update/delete — şu an dashboard cookie-auth only)
• RBAC per-project (custom roles + permission system)
• Anonymous users (Firebase pattern — guest → upgrade)
• SMS MFA (TOTP zaten var, SMS factor eklenir)
• Browser-safe public key tier (admin key separation)
• Email enumeration protection (uniform signup response timing)
• Stripe billing integration (free→paid plan upgrade self-service)
• Webhook delivery retry policy customization (current: 3-attempt sabit)