@seifer-webapp-factory/authentication 0.1.0

package/backend/templates/persistence/migrations/0001_auth.sql

@@ -0,0 +1,36 @@
+-- US-A0604 — authentication capability, migratie 0001_auth (raw SQL, DBA-review).
+-- Idempotent (IF NOT EXISTS). De TypeScript-variant in index.ts is de bron die de MigrationRunner draait.
+
+CREATE TABLE IF NOT EXISTS users (
+  id            text PRIMARY KEY,
+  identifier    text NOT NULL UNIQUE,
+  password_hash text,
+  verified      boolean NOT NULL DEFAULT false,
+  created_at    timestamptz NOT NULL DEFAULT now(),
+  updated_at    timestamptz NOT NULL DEFAULT now()
+);
+
+-- Single-use tokens voor e-mailverificatie (US-A0202) en wachtwoord-reset (US-A0501/0502).
+CREATE TABLE IF NOT EXISTS auth_one_time_tokens (
+  id          text PRIMARY KEY,       -- SHA-256-hash van het klare token
+  purpose     text NOT NULL,          -- 'email-verify' | 'password-reset'
+  payload     jsonb,                  -- { userId }
+  expires_at  bigint NOT NULL,        -- ms sinds epoch
+  consumed_at bigint                  -- ms sinds epoch; NULL zolang onverbruikt
+);
+CREATE INDEX IF NOT EXISTS auth_one_time_tokens_purpose_idx ON auth_one_time_tokens(purpose);
+
+-- Roterende refresh-tokens (US-A0301/0401/0403); used_at markeert rotatie/hergebruik.
+CREATE TABLE IF NOT EXISTS auth_refresh_tokens (
+  id         text PRIMARY KEY,        -- SHA-256-hash van het klare refresh-token
+  subject    text NOT NULL,           -- user id
+  expires_at bigint NOT NULL,
+  used_at    bigint
+);
+CREATE INDEX IF NOT EXISTS auth_refresh_tokens_subject_idx ON auth_refresh_tokens(subject);
+
+-- Access-token-denylist (revocatie op jti).
+CREATE TABLE IF NOT EXISTS auth_denied_access (
+  jti        text PRIMARY KEY,
+  expires_at bigint NOT NULL
+);

package/backend/templates/persistence/migrations/index.ts

@@ -0,0 +1,75 @@
+/**
+ * US-A0604 — Schema-migraties voor de authentication-capability, in het persistence-kit-{@link Migration}-
+ * formaat (stabiele id + idempotente `up`/`down`). De MigrationRunner past ze in volgorde toe en houdt
+ * een ledger bij. De raw SQL staat naast dit bestand in `0001_auth.sql` (documentatie/DBA-review).
+ *
+ * `0001_auth` legt vast:
+ *  - `users`                 — identiteit + wachtwoord-hash + verificatiestatus (US-A0201/0203)
+ *  - `auth_one_time_tokens`  — single-use verify/reset-tokens (US-A0202/0501/0502)
+ *  - `auth_refresh_tokens`   — roterende refresh-tokens (US-A0301/0401/0403)
+ *  - `auth_denied_access`    — access-token-denylist (revocatie)
+ * Ids zijn `text` (UUID's en SHA-256-hashes); tijd-kolommen voor tokens zijn `bigint` (ms sinds epoch).
+ */
+import type { Migration } from '@seifer-webapp-factory/kits/backend/persistence';
+
+const authInit: Migration = {
+  id: '0001_auth',
+  async up(ctx) {
+    await ctx.execute(`
+      CREATE TABLE IF NOT EXISTS users (
+        id            text PRIMARY KEY,
+        identifier    text NOT NULL UNIQUE,
+        password_hash text,
+        verified      boolean NOT NULL DEFAULT false,
+        created_at    timestamptz NOT NULL DEFAULT now(),
+        updated_at    timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await ctx.execute(`
+      CREATE TABLE IF NOT EXISTS auth_one_time_tokens (
+        id          text PRIMARY KEY,
+        purpose     text NOT NULL,
+        payload     jsonb,
+        expires_at  bigint NOT NULL,
+        consumed_at bigint
+      )
+    `);
+    await ctx.execute(
+      'CREATE INDEX IF NOT EXISTS auth_one_time_tokens_purpose_idx ON auth_one_time_tokens(purpose)',
+    );
+    await ctx.execute(`
+      CREATE TABLE IF NOT EXISTS auth_refresh_tokens (
+        id         text PRIMARY KEY,
+        subject    text NOT NULL,
+        expires_at bigint NOT NULL,
+        used_at    bigint
+      )
+    `);
+    await ctx.execute(
+      'CREATE INDEX IF NOT EXISTS auth_refresh_tokens_subject_idx ON auth_refresh_tokens(subject)',
+    );
+    await ctx.execute(`
+      CREATE TABLE IF NOT EXISTS auth_denied_access (
+        jti        text PRIMARY KEY,
+        expires_at bigint NOT NULL
+      )
+    `);
+  },
+  async down(ctx) {
+    await ctx.execute('DROP TABLE IF EXISTS auth_denied_access');
+    await ctx.execute('DROP TABLE IF EXISTS auth_refresh_tokens');
+    await ctx.execute('DROP TABLE IF EXISTS auth_one_time_tokens');
+    await ctx.execute('DROP TABLE IF EXISTS users');
+  },
+};
+
+/** Alle auth-migraties in toepassingsvolgorde. */
+export const authMigrations: Migration[] = [authInit];
+
+/** Tabellen die een test-reset-helper mag leegmaken (exclusief de migratie-ledger). */
+export const AUTH_MANAGED_TABLES = [
+  'users',
+  'auth_one_time_tokens',
+  'auth_refresh_tokens',
+  'auth_denied_access',
+];

package/backend/templates/persistence/pg-single-use-store.ts

@@ -0,0 +1,64 @@
+/**
+ * US-A0601 — Postgres-backed {@link SingleUseStore} voor e-mailverificatie- en wachtwoord-reset-tokens
+ * (tabel `auth_one_time_tokens`). `markConsumed` verbruikt atomair exact één keer (WHERE consumed_at IS
+ * NULL). Alleen de SHA-256-hash van het klare token wordt opgeslagen; het klare token is nooit
+ * persistent. `payload` is `jsonb` (reeds geparsed door `pg`).
+ */
+import type { Pool, Row } from '@seifer-webapp-factory/kits/backend/persistence';
+import type { SingleUseStore } from '@seifer-webapp-factory/kits/backend/auth';
+
+type OneTimeRow = Row & {
+  id: string;
+  purpose: string;
+  payload: unknown;
+  expiresAt: string;
+  consumedAt: string | null;
+};
+
+export function pgSingleUseStore(pool: Pool): SingleUseStore {
+  return {
+    async save(record) {
+      await pool.execute(
+        `INSERT INTO auth_one_time_tokens (id, purpose, payload, expires_at, consumed_at)
+         VALUES ($1, $2, $3, $4, $5)
+         ON CONFLICT (id) DO UPDATE SET
+           purpose     = EXCLUDED.purpose,
+           payload     = EXCLUDED.payload,
+           expires_at  = EXCLUDED.expires_at,
+           consumed_at = EXCLUDED.consumed_at`,
+        [
+          record.id,
+          record.purpose,
+          JSON.stringify(record.payload ?? null),
+          record.expiresAt,
+          record.consumedAt ?? null,
+        ],
+      );
+    },
+    async find(id) {
+      const { rows } = await pool.execute<OneTimeRow>(
+        `SELECT id, purpose, payload, expires_at AS "expiresAt", consumed_at AS "consumedAt"
+         FROM auth_one_time_tokens WHERE id = $1`,
+        [id],
+      );
+      const r = rows[0];
+      if (!r) return null;
+      return {
+        id: r.id,
+        purpose: r.purpose,
+        payload: r.payload,
+        expiresAt: Number(r.expiresAt),
+        consumedAt: r.consumedAt == null ? undefined : Number(r.consumedAt),
+      };
+    },
+    async markConsumed(id) {
+      const { rowCount } = await pool.execute(
+        `UPDATE auth_one_time_tokens
+         SET consumed_at = (EXTRACT(EPOCH FROM now()) * 1000)::bigint
+         WHERE id = $1 AND consumed_at IS NULL`,
+        [id],
+      );
+      return rowCount === 1;
+    },
+  };
+}

package/backend/templates/persistence/pg-token-store.ts

@@ -0,0 +1,75 @@
+/**
+ * US-A0601 — Postgres-backed {@link TokenStore}: refresh-token-rotatie (met hergebruik-detectie) +
+ * access-denylist. `markRefreshUsed` is atomair (alleen markeren als nog niet gebruikt) zodat
+ * hergebruik van een reeds-ingewisseld token betrouwbaar wordt gedetecteerd. `revokeAllForSubject`
+ * trekt in één statement ALLE nog-ongebruikte tokens van een subject in (US-A0502 reset → sessies weg).
+ * bigint-kolommen (ms sinds epoch) komen als string terug uit `pg`; we normaliseren naar `number`.
+ */
+import type { Pool, Row } from '@seifer-webapp-factory/kits/backend/persistence';
+import type { TokenStore } from '@seifer-webapp-factory/kits/backend/auth';
+
+type RefreshRow = Row & {
+  id: string;
+  subject: string;
+  expiresAt: string;
+  usedAt: string | null;
+};
+
+export function pgTokenStore(pool: Pool): TokenStore {
+  return {
+    async saveRefresh(record) {
+      await pool.execute(
+        `INSERT INTO auth_refresh_tokens (id, subject, expires_at, used_at)
+         VALUES ($1, $2, $3, $4)
+         ON CONFLICT (id) DO UPDATE SET
+           subject    = EXCLUDED.subject,
+           expires_at = EXCLUDED.expires_at,
+           used_at    = EXCLUDED.used_at`,
+        [record.id, record.subject, record.expiresAt, record.usedAt ?? null],
+      );
+    },
+    async findRefresh(id) {
+      const { rows } = await pool.execute<RefreshRow>(
+        `SELECT id, subject, expires_at AS "expiresAt", used_at AS "usedAt"
+         FROM auth_refresh_tokens WHERE id = $1`,
+        [id],
+      );
+      const r = rows[0];
+      if (!r) return null;
+      return {
+        id: r.id,
+        subject: r.subject,
+        expiresAt: Number(r.expiresAt),
+        usedAt: r.usedAt == null ? undefined : Number(r.usedAt),
+      };
+    },
+    async markRefreshUsed(id) {
+      const { rowCount } = await pool.execute(
+        `UPDATE auth_refresh_tokens
+         SET used_at = (EXTRACT(EPOCH FROM now()) * 1000)::bigint
+         WHERE id = $1 AND used_at IS NULL`,
+        [id],
+      );
+      return rowCount === 1;
+    },
+    async revokeAllForSubject(subject) {
+      await pool.execute(
+        `UPDATE auth_refresh_tokens
+         SET used_at = (EXTRACT(EPOCH FROM now()) * 1000)::bigint
+         WHERE subject = $1 AND used_at IS NULL`,
+        [subject],
+      );
+    },
+    async denyAccess(jti, expiresAt) {
+      await pool.execute(
+        `INSERT INTO auth_denied_access (jti, expires_at) VALUES ($1, $2)
+         ON CONFLICT (jti) DO NOTHING`,
+        [jti, expiresAt],
+      );
+    },
+    async isAccessDenied(jti) {
+      const { rowCount } = await pool.execute(`SELECT 1 FROM auth_denied_access WHERE jti = $1`, [jti]);
+      return rowCount > 0;
+    },
+  };
+}

package/backend/templates/persistence/pg-user-store.ts

@@ -0,0 +1,53 @@
+/**
+ * US-A0601 — Postgres-backed {@link UserStore} bovenop de persistence-kit-{@link Pool}. `save` is een
+ * upsert op de `id` (registratie én verify/reset-updates lopen hier doorheen). De kit interpreteert
+ * `identifier` niet; wij bewaren het e-mailadres als login-identifier. Geen credential-materiaal in
+ * queries dat verder reikt dan de hash-kolom.
+ */
+import type { Pool, Row } from '@seifer-webapp-factory/kits/backend/persistence';
+import type { UserRecord, UserStore } from '@seifer-webapp-factory/kits/backend/auth';
+
+type UserRow = Row & {
+  id: string;
+  identifier: string;
+  passwordHash: string | null;
+  verified: boolean;
+};
+
+const SELECT = 'SELECT id, identifier, password_hash AS "passwordHash", verified FROM users';
+
+function toRecord(r: UserRow): UserRecord {
+  return {
+    id: r.id,
+    identifier: r.identifier,
+    passwordHash: r.passwordHash ?? undefined,
+    verified: r.verified,
+  };
+}
+
+export function pgUserStore(pool: Pool): UserStore {
+  return {
+    async findByIdentifier(identifier) {
+      const { rows } = await pool.execute<UserRow>(`${SELECT} WHERE identifier = $1`, [identifier]);
+      return rows[0] ? toRecord(rows[0]) : null;
+    },
+    async findById(id) {
+      const { rows } = await pool.execute<UserRow>(`${SELECT} WHERE id = $1`, [id]);
+      return rows[0] ? toRecord(rows[0]) : null;
+    },
+    async save(user) {
+      const { rows } = await pool.execute<UserRow>(
+        `INSERT INTO users (id, identifier, password_hash, verified, updated_at)
+         VALUES ($1, $2, $3, $4, now())
+         ON CONFLICT (id) DO UPDATE SET
+           identifier    = EXCLUDED.identifier,
+           password_hash = EXCLUDED.password_hash,
+           verified      = EXCLUDED.verified,
+           updated_at    = now()
+         RETURNING id, identifier, password_hash AS "passwordHash", verified`,
+        [user.id, user.identifier, user.passwordHash ?? null, user.verified ?? false],
+      );
+      return toRecord(rows[0]!);
+    },
+  };
+}

package/backend/templates/security/cookies.ts

@@ -0,0 +1,89 @@
+/**
+ * Cookie-helpers voor de auth-surface (US-A0703). Het roterende refresh-token gaat NOOIT in de
+ * response-body maar in een `httpOnly`+`Secure`+`SameSite`-cookie; het CSRF-token gaat in een
+ * *leesbare* (niet-httpOnly) cookie zodat de client het via een header kan terugspiegelen
+ * (double-submit). Deze module bevat pure string-helpers — geen framework-afhankelijkheid.
+ */
+
+/** Naam van de httpOnly refresh-token-cookie. */
+export const REFRESH_COOKIE = 'auth_refresh_token';
+/** Naam van de leesbare CSRF-cookie (double-submit). */
+export const CSRF_COOKIE = 'auth_csrf';
+/** Header waarin de client het CSRF-token terugspiegelt. */
+export const CSRF_HEADER = 'x-csrf-token';
+
+/** Instelbaar cookie-gedrag; `secure` staat productie-side altijd aan (achter TLS). */
+export interface CookieOptions {
+  secure: boolean;
+  sameSite: 'Strict' | 'Lax' | 'None';
+  /** Pad waarop het refresh-token geldig is; standaard de auth-routes. */
+  refreshPath: string;
+}
+
+export const DEFAULT_COOKIE_OPTIONS: CookieOptions = {
+  secure: true,
+  sameSite: 'Strict',
+  refreshPath: '/auth',
+};
+
+/** Parse een rauwe `Cookie`-header naar een naam→waarde-map (leeg bij afwezigheid). */
+export function parseCookies(header: string | undefined): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (!header) return out;
+  for (const part of header.split(';')) {
+    const eq = part.indexOf('=');
+    if (eq < 0) continue;
+    const name = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (name) out[name] = decodeURIComponent(value);
+  }
+  return out;
+}
+
+/** Bouw de `Set-Cookie`-string voor het refresh-token (httpOnly + Secure + SameSite). */
+export function refreshSetCookie(value: string, ttlSeconds: number, opts: CookieOptions): string {
+  return serializeCookie(REFRESH_COOKIE, value, {
+    httpOnly: true,
+    secure: opts.secure,
+    sameSite: opts.sameSite,
+    path: opts.refreshPath,
+    maxAge: ttlSeconds,
+  });
+}
+
+/** Bouw de `Set-Cookie`-string die het refresh-token wist (logout). */
+export function clearRefreshSetCookie(opts: CookieOptions): string {
+  return serializeCookie(REFRESH_COOKIE, '', {
+    httpOnly: true,
+    secure: opts.secure,
+    sameSite: opts.sameSite,
+    path: opts.refreshPath,
+    maxAge: 0,
+  });
+}
+
+/** Bouw de `Set-Cookie`-string voor het (leesbare) CSRF-token. */
+export function csrfSetCookie(value: string, opts: CookieOptions): string {
+  return serializeCookie(CSRF_COOKIE, value, {
+    httpOnly: false,
+    secure: opts.secure,
+    sameSite: opts.sameSite,
+    path: '/',
+  });
+}
+
+interface SerializeOptions {
+  httpOnly: boolean;
+  secure: boolean;
+  sameSite: 'Strict' | 'Lax' | 'None';
+  path: string;
+  maxAge?: number;
+}
+
+function serializeCookie(name: string, value: string, o: SerializeOptions): string {
+  const parts = [`${name}=${encodeURIComponent(value)}`, `Path=${o.path}`, `SameSite=${o.sameSite}`];
+  if (o.httpOnly) parts.push('HttpOnly');
+  if (o.secure) parts.push('Secure');
+  if (o.maxAge !== undefined) parts.push(`Max-Age=${o.maxAge}`);
+  return parts.join('; ');
+}

package/backend/templates/security/csrf.ts

@@ -0,0 +1,44 @@
+/**
+ * CSRF-bescherming via double-submit (US-A0703). De server zet een leesbare CSRF-cookie; de client
+ * spiegelt die waarde terug in de `X-CSRF-Token`-header. Op state-changing routes moeten cookie én
+ * header aanwezig zijn én exact overeenkomen. De vergelijking is timing-safe (geen lek via response-tijd).
+ */
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { CSRF_COOKIE, CSRF_HEADER, parseCookies } from './cookies.js';
+
+/** Genereer een onraadbaar CSRF-token (url-safe). */
+export function generateCsrfToken(): string {
+  return randomBytes(32).toString('base64url');
+}
+
+/** Minimale request-vorm die de CSRF-check nodig heeft. */
+export interface CsrfRequestLike {
+  headers: Record<string, string | string[] | undefined>;
+}
+
+/** Lees het CSRF-token uit de cookie (of `undefined`). */
+export function csrfCookieValue(req: CsrfRequestLike): string | undefined {
+  const raw = req.headers['cookie'];
+  const header = Array.isArray(raw) ? raw.join('; ') : raw;
+  return parseCookies(header)[CSRF_COOKIE];
+}
+
+/** Lees het teruggespiegelde CSRF-token uit de header (of `undefined`). */
+export function csrfHeaderValue(req: CsrfRequestLike): string | undefined {
+  const raw = req.headers[CSRF_HEADER];
+  return Array.isArray(raw) ? raw[0] : raw;
+}
+
+/**
+ * Valideer double-submit: cookie én header aanwezig en gelijk. Retourneert `false` bij ontbreken of
+ * mismatch — de aanroeper mapt dat naar `csrf_failed` (403).
+ */
+export function isCsrfValid(req: CsrfRequestLike): boolean {
+  const cookie = csrfCookieValue(req);
+  const header = csrfHeaderValue(req);
+  if (!cookie || !header) return false;
+  const a = Buffer.from(cookie);
+  const b = Buffer.from(header);
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(a, b);
+}

package/backend/templates/security/headers.ts

@@ -0,0 +1,30 @@
+/**
+ * Security-headers (US-A0704). Een defensieve, framework-neutrale set die op elke auth-response wordt
+ * gezet. Doel: geen MIME-sniffing, geen clickjacking, geen referrer-lek, en caches die geen
+ * gevoelige auth-responses bewaren. De redactie van secrets/tokens uit foutbodies gebeurt in de
+ * controller-fout-mapping (zie ook `redaction.ts`).
+ */
+
+/** Naam→waarde van de standaard security-headers. */
+export const SECURITY_HEADERS: Readonly<Record<string, string>> = Object.freeze({
+  'X-Content-Type-Options': 'nosniff',
+  'X-Frame-Options': 'DENY',
+  'Referrer-Policy': 'no-referrer',
+  'Cross-Origin-Opener-Policy': 'same-origin',
+  'Cross-Origin-Resource-Policy': 'same-origin',
+  // Auth-responses bevatten tokens/identiteit → nooit cachen.
+  'Cache-Control': 'no-store',
+  'Pragma': 'no-cache',
+});
+
+/** Minimale response-vorm om headers te zetten (express-compatibel). */
+export interface HeaderResponseLike {
+  setHeader(name: string, value: string): unknown;
+}
+
+/** Zet de volledige security-headerset op de response. */
+export function applySecurityHeaders(res: HeaderResponseLike): void {
+  for (const [name, value] of Object.entries(SECURITY_HEADERS)) {
+    res.setHeader(name, value);
+  }
+}

package/backend/templates/security/redaction.ts

@@ -0,0 +1,38 @@
+/**
+ * No-secret-leak redactie (US-A0704). De contract-foutbody is bewust smal: `{ code, message, fields? }`
+ * — geen stacktraces, geen tokens, geen wachtwoorden, geen "bestaat dit e-mailadres"-signaal. Deze
+ * helper is een laatste vangnet: hij verwijdert per ongeluk meegelifte gevoelige sleutels uit een
+ * object voordat het ooit de wire raakt. De primaire verdediging is dat de mechanism-laag generieke
+ * `AuthModuleError`-codes gooit en de controller ALLEEN `{ code, message, fields? }` serialiseert.
+ */
+
+/** Sleutels die nooit in een (fout)response mogen belanden. */
+const SENSITIVE_KEYS = [
+  'password',
+  'passwordhash',
+  'password_hash',
+  'token',
+  'refreshtoken',
+  'refresh_token',
+  'accesstoken',
+  'access_token',
+  'secret',
+  'authorization',
+  'cookie',
+  'set-cookie',
+];
+
+/** Redigeer gevoelige sleutels (recursief) uit een willekeurig object voor safe logging/serialisatie. */
+export function redactSecrets<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return value.map((v) => redactSecrets(v)) as unknown as T;
+  }
+  if (value && typeof value === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = SENSITIVE_KEYS.includes(key.toLowerCase()) ? '[redacted]' : redactSecrets(val);
+    }
+    return out as unknown as T;
+  }
+  return value;
+}

package/dist/backend/src/errors.d.ts

@@ -0,0 +1,12 @@
+import type { AuthErrorCode } from '../../contract/index.js';
+/** Fout van de mechanism-laag, gedragen door een contract-`AuthErrorCode`. */
+export declare class AuthModuleError extends Error {
+    readonly code: AuthErrorCode;
+    constructor(code: AuthErrorCode, message?: string);
+}
+/**
+ * Vertaal een kit-fout naar een {@link AuthModuleError}, of `undefined` als de fout niet uit de kit komt
+ * (dan laat de aanroeper 'm bubbelen). Reeds-vertaalde fouten worden ongewijzigd doorgegeven.
+ */
+export declare function asModuleError(err: unknown): AuthModuleError | undefined;
+//# sourceMappingURL=errors.d.ts.map

package/dist/backend/src/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../backend/src/errors.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAgB7D,8EAA8E;AAC9E,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;gBACjB,IAAI,EAAE,aAAa,EAAE,OAAO,GAAE,MAAuB;CAMlE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,eAAe,GAAG,SAAS,CAsBvE"}

package/dist/backend/src/errors.js

@@ -0,0 +1,55 @@
+/**
+ * Foutvertaling: kit-fouten → de gedeelde contract-`AuthErrorCode`-taxonomie.
+ *
+ * De boodschappen blijven generiek: ze lekken nooit secrets/tokens of of een e-mail bestaat
+ * (no-enumeration). Onbekende (niet-kit) fouten worden NIET geslikt — die laten we bubbelen zodat de
+ * surface-laag ze als 500 afhandelt, zonder details te lekken.
+ */
+import { AuthError, InvalidCredentialsError, SingleUseTokenError, TokenError } from '@seifer-webapp-factory/kits/backend/auth';
+/** Generieke, veilige boodschappen per code (nooit rauwe details). */
+const MESSAGES = {
+    invalid_credentials: 'Ongeldige inloggegevens',
+    email_taken: 'E-mailadres is al in gebruik',
+    weak_password: 'Wachtwoord voldoet niet aan het beleid',
+    token_invalid: 'Token is ongeldig',
+    token_expired: 'Token is verlopen',
+    email_not_verified: 'E-mailadres is nog niet geverifieerd',
+    rate_limited: 'Te veel verzoeken',
+    csrf_failed: 'CSRF-controle mislukt',
+    unauthenticated: 'Niet geauthenticeerd',
+    validation_failed: 'Validatie mislukt',
+};
+/** Fout van de mechanism-laag, gedragen door een contract-`AuthErrorCode`. */
+export class AuthModuleError extends Error {
+    code;
+    constructor(code, message = MESSAGES[code]) {
+        super(message);
+        this.name = 'AuthModuleError';
+        this.code = code;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Vertaal een kit-fout naar een {@link AuthModuleError}, of `undefined` als de fout niet uit de kit komt
+ * (dan laat de aanroeper 'm bubbelen). Reeds-vertaalde fouten worden ongewijzigd doorgegeven.
+ */
+export function asModuleError(err) {
+    if (err instanceof AuthModuleError)
+        return err;
+    if (err instanceof InvalidCredentialsError) {
+        return new AuthModuleError('invalid_credentials');
+    }
+    if (err instanceof TokenError) {
+        // 'invalid' | 'revoked' | 'reuse' → token_invalid; 'expired' → token_expired.
+        return new AuthModuleError(err.reason === 'expired' ? 'token_expired' : 'token_invalid');
+    }
+    if (err instanceof SingleUseTokenError) {
+        // 'invalid' | 'consumed' → token_invalid; 'expired' → token_expired.
+        return new AuthModuleError(err.reason === 'expired' ? 'token_expired' : 'token_invalid');
+    }
+    if (err instanceof AuthError && err.code === 'IDENTIFIER_TAKEN') {
+        return new AuthModuleError('email_taken');
+    }
+    return undefined;
+}
+//# sourceMappingURL=errors.js.map

package/dist/backend/src/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../backend/src/errors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,SAAS,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAG/H,sEAAsE;AACtE,MAAM,QAAQ,GAAkC;IAC9C,mBAAmB,EAAE,yBAAyB;IAC9C,WAAW,EAAE,8BAA8B;IAC3C,aAAa,EAAE,wCAAwC;IACvD,aAAa,EAAE,mBAAmB;IAClC,aAAa,EAAE,mBAAmB;IAClC,kBAAkB,EAAE,sCAAsC;IAC1D,YAAY,EAAE,mBAAmB;IACjC,WAAW,EAAE,uBAAuB;IACpC,eAAe,EAAE,sBAAsB;IACvC,iBAAiB,EAAE,mBAAmB;CACvC,CAAC;AAEF,8EAA8E;AAC9E,MAAM,OAAO,eAAgB,SAAQ,KAAK;IAC/B,IAAI,CAAgB;IAC7B,YAAY,IAAmB,EAAE,UAAkB,QAAQ,CAAC,IAAI,CAAC;QAC/D,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC;CACF;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,GAAY;IACxC,IAAI,GAAG,YAAY,eAAe;QAAE,OAAO,GAAG,CAAC;IAE/C,IAAI,GAAG,YAAY,uBAAuB,EAAE,CAAC;QAC3C,OAAO,IAAI,eAAe,CAAC,qBAAqB,CAAC,CAAC;IACpD,CAAC;IAED,IAAI,GAAG,YAAY,UAAU,EAAE,CAAC;QAC9B,8EAA8E;QAC9E,OAAO,IAAI,eAAe,CAAC,GAAG,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;IAC3F,CAAC;IAED,IAAI,GAAG,YAAY,mBAAmB,EAAE,CAAC;QACvC,qEAAqE;QACrE,OAAO,IAAI,eAAe,CAAC,GAAG,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;IAC3F,CAAC;IAED,IAAI,GAAG,YAAY,SAAS,IAAI,GAAG,CAAC,IAAI,KAAK,kBAAkB,EAAE,CAAC;QAChE,OAAO,IAAI,eAAe,CAAC,aAAa,CAAC,CAAC;IAC5C,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/backend/src/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * authentication — backend-mechanism (flow-services). De verticale, framework-vrije servicelaag die de
+ * `auth`-kit componeert achter het gedeelde contract. Surface (NestJS-controllers/guards) leeft elders en
+ * consumeert deze barrel.
+ */
+export { registerUser, verifyEmail, login, refresh, logout, forgotPassword, resetPassword, type SessionResult, } from './services.js';
+export { AuthModuleError, asModuleError } from './errors.js';
+export type { AuthModuleDeps, AuthModuleConfig, AuthPurposes, PasswordPolicy, TokenServicePort, SingleUseServicePort, } from './ports.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/backend/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../backend/src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACL,YAAY,EACZ,WAAW,EACX,KAAK,EACL,OAAO,EACP,MAAM,EACN,cAAc,EACd,aAAa,EACb,KAAK,aAAa,GACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE7D,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,YAAY,CAAC"}

package/dist/backend/src/index.js

@@ -0,0 +1,8 @@
+/**
+ * authentication — backend-mechanism (flow-services). De verticale, framework-vrije servicelaag die de
+ * `auth`-kit componeert achter het gedeelde contract. Surface (NestJS-controllers/guards) leeft elders en
+ * consumeert deze barrel.
+ */
+export { registerUser, verifyEmail, login, refresh, logout, forgotPassword, resetPassword, } from './services.js';
+export { AuthModuleError, asModuleError } from './errors.js';
+//# sourceMappingURL=index.js.map

package/dist/backend/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../backend/src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACL,YAAY,EACZ,WAAW,EACX,KAAK,EACL,OAAO,EACP,MAAM,EACN,cAAc,EACd,aAAa,GAEd,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}