@bajustone/fortress 1.0.0-rc.1

package/dist/sveltekit.d.cts

@@ -0,0 +1,420 @@
+import { RequestEvent, Handle, ActionFailure } from '@sveltejs/kit';
+import { F as Fortress, V as AuthCookiePayload } from './fortress-BmSvFfqK.cjs';
+import { S as Subject, T as TokenClaims, m as AuthChallenge } from './types-et0R8tsC.cjs';
+import { D as DatabaseAdapter } from './index-CxEkfCA0.cjs';
+import { E as EndpointDefinition, S as StandardSchemaV1 } from './config-GtlVt6ZD.cjs';
+import { P as ProtectedRouteContext, a as ProtectOptions } from './protect-D1v_0upK.cjs';
+export { b as ProtectedRouteTarget } from './protect-D1v_0upK.cjs';
+import './index-D054pcb-.cjs';
+import './auth-service-BcyQ2PuZ.cjs';
+import './plugins/api-key.cjs';
+import './jwt.cjs';
+import './plugins/audit-log.cjs';
+import './plugins/data-isolation.cjs';
+import './plugins/email-verification.cjs';
+import './plugins/magic-link.cjs';
+import './plugins/oauth.cjs';
+import './plugins/social-login.cjs';
+import './plugins/tenancy.cjs';
+import './plugins/two-factor.cjs';
+import './plugins/webauthn.cjs';
+import '@simplewebauthn/server';
+
+/**
+ * SvelteKit adapter types. Public handle/action signatures are anchored to
+ * the real optional `@sveltejs/kit` peer so strict-mode consumers can assign
+ * them without casts. Small request/cookie subsets remain for framework-free
+ * helpers and tests; every real RequestEvent structurally satisfies them.
+ */
+
+/** Cookie options accepted by SvelteKit's `event.cookies.set` / `delete`. */
+interface SvelteKitCookieOptions {
+    path?: string;
+    domain?: string;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none' | boolean;
+    maxAge?: number;
+    expires?: Date;
+}
+/** SvelteKit `Cookies` API surface used by the fortress adapter. */
+interface SvelteKitCookies {
+    get: (name: string) => string | undefined;
+    set: (name: string, value: string, opts: SvelteKitCookieOptions & {
+        path: string;
+    }) => void;
+    delete: (name: string, opts: SvelteKitCookieOptions & {
+        path: string;
+    }) => void;
+    getAll?: () => {
+        name: string;
+        value: string;
+    }[];
+}
+/**
+ * Minimal `RequestEvent` shape consumed by the adapter. Compatible by
+ * structural typing with `@sveltejs/kit`'s real `RequestEvent`. The
+ * `locals.fortress` field comes from the consumer augmenting `App.Locals`
+ * with {@link FortressLocals}.
+ *
+ * `TLocals` is constrained to `object` (not `Record<string, unknown>`) so
+ * the {@link FortressLocals} interface — which only declares the
+ * `fortress` key without an index signature — satisfies it.
+ */
+interface SvelteKitRequestEvent<TLocals extends object = object> {
+    request: Request;
+    url: URL;
+    cookies: SvelteKitCookies;
+    locals: TLocals;
+    params: Record<string, string>;
+    setHeaders?: (headers: Record<string, string>) => void;
+}
+/** Exact SvelteKit `Handle` hook signature, including the resolve options overload. */
+type SvelteKitHandle = Handle;
+/** SvelteKit-compatible form action signature with a narrowed result type. */
+type SvelteKitAction<TResult = unknown> = (event: RequestEvent) => Promise<TResult> | TResult;
+/**
+ * Shape of `event.locals.fortress` after the fortress handle hook runs.
+ *
+ * Consumers augment SvelteKit's `App.Locals` with this interface so server
+ * load functions and `+server.ts` handlers can read the auth context with
+ * full type safety.
+ *
+ * @example
+ * ```ts
+ * // src/app.d.ts
+ * import type { FortressLocals } from '@bajustone/fortress/sveltekit';
+ *
+ * declare global {
+ *   namespace App {
+ *     interface Locals extends FortressLocals {}
+ *   }
+ * }
+ * ```
+ */
+interface FortressLocals {
+    fortress: {
+        /**
+         * Resolved principal for the current request. Set for every
+         * authenticated request regardless of credential type (JWT, api-key,
+         * future OAuth client_credentials, mTLS). Check `subject.type` to
+         * distinguish `USER` / `SERVICE_ACCOUNT` / `GROUP`.
+         */
+        subject?: Subject;
+        /**
+         * Convenience alias for `subject.id` — set **only** when
+         * `subject.type === 'USER'`. Non-USER principals (e.g. a service
+         * account via api-key) leave this undefined; fall back to `subject`.
+         */
+        userId?: string;
+        /**
+         * Verified JWT claims, if the request was authenticated via a JWT.
+         * Plugin-resolved principals (api-key, etc.) do not populate this.
+         */
+        claims?: TokenClaims;
+        /** Credential-level narrowing scopes (for example API-key scopes). */
+        scopes?: string[] | null;
+        /** Per-request DB adapter with plugin `wrapAdapter` chain applied. */
+        db?: DatabaseAdapter;
+        /** Lazily compute a model-scoped DB adapter (data-isolation aware). */
+        getScopedDb?: (model: string) => Promise<DatabaseAdapter>;
+    };
+}
+/** Options accepted by {@link createSvelteKitHandle}. */
+interface SvelteKitAdapterOptions {
+    /**
+     * Path prefix the fortress routes live under (defaults to `/api`).
+     *
+     * Example: with `basePath: '/api'`, the request `/api/auth/login` is
+     * internally rewritten to `/auth/login` before being passed to
+     * `fortress.handleRequest`. Plugin and IAM routes follow the same prefix.
+     */
+    basePath?: string;
+    /**
+     * Optional declarative route → `(resource, action)` map for user-owned
+     * routes. Used by the user-route RBAC pass to call
+     * `fortress.iam.checkPermission` for non-fortress paths. Format:
+     * `'GET /api/users': { resource: 'user', action: 'list' }`.
+     */
+    routeMap?: Record<string, {
+        resource: string;
+        action: string;
+    }>;
+    /** Behavior for user-owned routes absent from routeMap (default: allow). */
+    unmappedRoutes?: 'allow' | 'deny';
+    /**
+     * Paths the user-route RBAC pass should skip entirely (supports `*`).
+     * Example: `['/api/health', '/api/public/*']`.
+     */
+    skipPaths?: string[];
+}
+
+/**
+ * SvelteKit form-action helpers for the common auth flows.
+ *
+ * Use these in `+page.server.ts` to wire `<form method="POST">` to
+ * fortress's auth methods. They handle:
+ *
+ * - parsing form data
+ * - calling `fortress.auth.*`
+ * - setting cookies via `event.cookies.set` (so SvelteKit's `Set-Cookie`
+ *   handling sees them, not just the browser)
+ * - returning `fail(...)` on `FortressError`
+ * - throwing a `redirect(...)` on success when `redirectTo` is supplied
+ *
+ * Redirects and failures use SvelteKit's real `redirect()` / `fail()`
+ * primitives, so the action runtime recognizes them without casts or
+ * raw-Response 500s.
+ *
+ * @example
+ * ```ts
+ * // src/routes/login/+page.server.ts
+ * import { fortressActions } from '@bajustone/fortress/sveltekit';
+ * import { fortress } from '$lib/server/fortress';
+ *
+ * export const actions = {
+ *   default: fortressActions.login(fortress, { redirectTo: '/dashboard' }),
+ * };
+ * ```
+ */
+
+/** Shape returned by form-action helpers when something goes wrong. */
+type FortressActionFailure = ActionFailure<{
+    error: string;
+    code?: string;
+}>;
+/** Discriminated result returned when no `redirectTo` is configured. */
+type FortressActionSuccess = {
+    success: true;
+    pending: false;
+} | {
+    success: true;
+    pending: true;
+    challenge: AuthChallenge;
+};
+/** Common options for the auth-issuing helpers. */
+interface FortressActionOptions {
+    /**
+     * On success, throw a redirect to this path. SvelteKit's action runtime
+     * picks up the thrown 3xx and emits a normal HTTP redirect.
+     */
+    redirectTo?: string;
+}
+/** Type of the {@link fortressActions} namespace — explicit so JSR's slow-type check is happy. */
+interface FortressActions {
+    login: (fortress: Fortress<any, any>, opts?: FortressActionOptions) => SvelteKitAction<FortressActionFailure | FortressActionSuccess>;
+    register: (fortress: Fortress<any, any>, opts?: FortressActionOptions) => SvelteKitAction<FortressActionFailure | FortressActionSuccess>;
+    logout: (fortress: Fortress<any, any>, opts?: FortressActionOptions) => SvelteKitAction<FortressActionSuccess>;
+    refresh: (fortress: Fortress<any, any>) => SvelteKitAction<FortressActionFailure | FortressActionSuccess>;
+}
+/** Form-action helpers exported as a single namespace. */
+declare const fortressActions: FortressActions;
+
+/**
+ * Optional catch-all `+server.ts` escape hatch.
+ *
+ * Lets users colocate Fortress routes inside their normal `src/routes/`
+ * tree instead of (or in addition to) the handle-hook approach.
+ *
+ * @example
+ * ```ts
+ * // src/routes/api/fortress/[...path]/+server.ts
+ * import { toSvelteKitHandler } from '@bajustone/fortress/sveltekit';
+ * import { fortress } from '$lib/server/fortress';
+ *
+ * export const { GET, POST, PUT, DELETE, PATCH } = toSvelteKitHandler(fortress);
+ * ```
+ */
+
+/** Per-method handler signature compatible with SvelteKit `+server.ts` exports. */
+type SvelteKitRouteHandler = (event: SvelteKitRequestEvent) => Promise<Response>;
+/**
+ * Build a `{ GET, POST, PUT, DELETE, PATCH }` set of handlers that all
+ * delegate to `fortress.handleRequest`. Suitable for `export const { ... } =
+ * toSvelteKitHandler(fortress)` in a catch-all `+server.ts`.
+ */
+declare function toSvelteKitHandler(fortress: Fortress<any, any>): {
+    GET: SvelteKitRouteHandler;
+    POST: SvelteKitRouteHandler;
+    PUT: SvelteKitRouteHandler;
+    DELETE: SvelteKitRouteHandler;
+    PATCH: SvelteKitRouteHandler;
+};
+
+/**
+ * SvelteKit cookie bridging.
+ *
+ * Translates between fortress's auth result objects and SvelteKit's
+ * `event.cookies` API. Cookie attributes (name, secure, sameSite, path,
+ * domain) come from the resolved {@link ResolvedCookieConfig} on the
+ * Fortress instance, so SvelteKit, Hono, and Express all emit cookies with
+ * the same shape.
+ */
+
+/**
+ * Set the access + refresh cookies on a SvelteKit `RequestEvent` from a
+ * fortress auth result. Used by the form-action helpers and the auto-refresh
+ * path inside `createSvelteKitHandle`.
+ */
+declare function setAuthCookies(event: SvelteKitRequestEvent, fortress: Fortress<any, any>, payload: AuthCookiePayload): void;
+/** Clear both fortress auth cookies (logout). */
+declare function clearAuthCookies(event: SvelteKitRequestEvent, fortress: Fortress<any, any>): void;
+/**
+ * Replay any `Set-Cookie` headers from a `Response` (typically returned by
+ * `fortress.handleRequest`) through `event.cookies.set` so they're visible
+ * to subsequent same-request reads. Returns the original response unchanged
+ * — the cookies are already on it; this just mirrors them into SvelteKit's
+ * cookie jar for in-request use.
+ */
+declare function replayCookies(response: Response, event: SvelteKitRequestEvent): void;
+
+/**
+ * `createSvelteKitHandle(fortress, options)` — primary entrypoint for the
+ * SvelteKit adapter.
+ *
+ * Returns a SvelteKit `Handle` hook that:
+ *
+ * 1. Short-circuits during `vite build` prerender (caller passes
+ *    `building` to opt out).
+ * 2. Intercepts Fortress-managed paths (`/auth/*`, `/iam/*`, plugin paths)
+ *    by calling `fortress.handleRequest(event.request)` and returning the
+ *    `Response` directly. This bypasses SvelteKit's built-in CSRF check
+ *    (which only runs inside `resolve(event)`), but `handleRequest` runs
+ *    Fortress's own pipeline CSRF check (H5) in its place.
+ * 3. For user routes, runs plugin `before-auth` middleware, extracts the
+ *    access token (cookie-first, Bearer fallback), verifies it,
+ *    auto-refreshes when expired, populates `event.locals.fortress`, runs
+ *    plugin `after-auth` and (when a route map matches) RBAC, then
+ *    delegates to `resolve(event)`.
+ *
+ * Compose with `sequence()` from `@sveltejs/kit/hooks` if you have other
+ * handles.
+ *
+ * @example
+ * ```ts
+ * // src/hooks.server.ts
+ * import { sequence } from '@sveltejs/kit/hooks';
+ * import { createSvelteKitHandle } from '@bajustone/fortress/sveltekit';
+ * import { fortress } from '$lib/server/fortress';
+ *
+ * export const handle = sequence(
+ *   createSvelteKitHandle(fortress, { basePath: '/api' }),
+ * );
+ * ```
+ */
+
+/** Build the SvelteKit `handle` hook for a Fortress instance. */
+declare function createSvelteKitHandle(fortress: Fortress<any, any>, options?: SvelteKitAdapterOptions): SvelteKitHandle;
+
+/**
+ * Read fortress request context from a SvelteKit `RequestEvent`.
+ *
+ * Each helper throws `FortressError('UNAUTHORIZED')` when the field is
+ * missing — typically because the auth handle hook didn't populate
+ * `event.locals.fortress.userId` (i.e. the request was anonymous).
+ */
+
+type EventWithFortress = SvelteKitRequestEvent<FortressLocals>;
+/**
+ * Read the resolved principal from the event, throwing 401 if missing.
+ * Works for every subject kind (`USER`, `SERVICE_ACCOUNT`, ...).
+ */
+declare function getSubject(event: EventWithFortress): Subject;
+/**
+ * Read the authenticated user ID. Throws 401 when the request was
+ * authenticated by a non-USER subject (e.g. a service account via
+ * api-key) — use {@link getSubject} for handlers that accept any
+ * principal.
+ */
+declare function getUserId(event: EventWithFortress): string;
+/**
+ * Read the verified JWT claims. Only populated when the request was
+ * authenticated via a JWT — api-key principals have no JWT claims and
+ * this helper throws 401.
+ */
+declare function getClaims(event: EventWithFortress): TokenClaims;
+/** Read the per-request DB adapter (with plugin wrappers applied). */
+declare function getDb(event: EventWithFortress): DatabaseAdapter;
+/**
+ * Read the per-request DB adapter scoped to a specific model. Applies any
+ * active row-level scope rules from data-isolation plugins.
+ */
+declare function getScopedDb(event: EventWithFortress, model: string): Promise<DatabaseAdapter>;
+
+/**
+ * SvelteKit-flavoured host callback. `E` flows in from the endpoint passed
+ * to `protectedRoute()`, so `ctx.body` / `ctx.query` / `ctx.params` /
+ * `ctx.input` are typed from the endpoint's phantom generics. String
+ * targets degrade to the loose default.
+ */
+type SvelteKitProtectedRouteHandler<E extends EndpointDefinition<any, any, any, any> = EndpointDefinition, TResult = unknown> = (event: SvelteKitRequestEvent, ctx: ProtectedRouteContext<E>) => TResult | Response | Promise<TResult | Response>;
+/**
+ * Wrap a host-owned SvelteKit route/action in Fortress's protection pipeline.
+ *
+ * Two overloads, mirroring `protect()`:
+ *
+ * - **Typed target** — passing an `EndpointDefinition` flows its phantom
+ *   generics through `ctx`.
+ * - **String target** — passing a unique `handler` name keeps the loose
+ *   `Record<string, unknown>` / `unknown` typing.
+ */
+declare function protectedRoute<E extends EndpointDefinition<any, any, any, any>, TResult = unknown>(fortress: Fortress<any, any>, target: E, handler: SvelteKitProtectedRouteHandler<E, TResult>, options?: ProtectOptions): (event: SvelteKitRequestEvent) => Promise<Response>;
+declare function protectedRoute<TResult = unknown>(fortress: Fortress<any, any>, target: string, handler: SvelteKitProtectedRouteHandler<EndpointDefinition, TResult>, options?: ProtectOptions): (event: SvelteKitRequestEvent) => Promise<Response>;
+
+/**
+ * Typed extraction-and-validation helpers for SvelteKit `+server.ts` handlers
+ * and form actions.
+ *
+ * These helpers extract request data (body, params, query) **and validate
+ * it at runtime** against the supplied Standard Schema. On success they
+ * return the parsed value with full TypeScript inference; on failure they
+ * throw `FortressError('VALIDATION_ERROR', 422)` — the same shape every
+ * fortress-managed endpoint produces — so the existing SvelteKit error
+ * mapping (via `errorToResponse`) formats it identically.
+ *
+ * Works with any Standard Schema V1 library: Zod, Valibot, ArkType, or
+ * fortress's built-in schema builders.
+ *
+ * @example
+ * ```ts
+ * // src/routes/api/users/[id]/+server.ts
+ * import { vBody, vParam } from '@bajustone/fortress/sveltekit';
+ * import { obj, str } from '@bajustone/fortress';
+ *
+ * const UpdateBody = obj({ name: str() }, 'name');
+ * const Params = obj({ id: str() }, 'id');
+ *
+ * export async function PATCH(event) {
+ *   const { id }   = await vParam(event, Params);
+ *   const { name } = await vBody(event, UpdateBody);
+ *   // ...
+ * }
+ * ```
+ *
+ * Validation runs per call, so the first failing helper throws and any
+ * downstream helpers in the same handler do not run. If you need to
+ * aggregate body+query+params issues into a single response, use the
+ * framework-agnostic `validateRequest` from `@bajustone/fortress` instead.
+ */
+
+/** Infer the output type of a Standard Schema V1 schema. */
+type InferOutput<T extends StandardSchemaV1> = StandardSchemaV1.InferOutput<T>;
+/**
+ * Extract and validate the JSON request body. Returns the parsed value typed
+ * as `InferOutput<T>`, or throws `FortressError('VALIDATION_ERROR', 422)`.
+ */
+declare function vBody<T extends StandardSchemaV1>(event: SvelteKitRequestEvent, schema: T): Promise<InferOutput<T>>;
+/**
+ * Extract and validate route parameters from a `[param]`-style file. Returns
+ * the parsed value typed as `InferOutput<T>`, or throws
+ * `FortressError('VALIDATION_ERROR', 422)`.
+ */
+declare function vParam<T extends StandardSchemaV1>(event: SvelteKitRequestEvent, schema: T): Promise<InferOutput<T>>;
+/**
+ * Extract and validate query parameters from `event.url.searchParams`.
+ * Returns the parsed value typed as `InferOutput<T>`, or throws
+ * `FortressError('VALIDATION_ERROR', 422)`.
+ */
+declare function vQuery<T extends StandardSchemaV1>(event: SvelteKitRequestEvent, schema: T): Promise<InferOutput<T>>;
+
+export { type FortressActionFailure, type FortressActionOptions, type FortressActionSuccess, type FortressActions, type FortressLocals, type InferOutput, ProtectOptions, ProtectedRouteContext, type SvelteKitAction, type SvelteKitAdapterOptions, type SvelteKitCookieOptions, type SvelteKitCookies, type SvelteKitHandle, type SvelteKitProtectedRouteHandler, type SvelteKitRequestEvent, type SvelteKitRouteHandler, clearAuthCookies, createSvelteKitHandle, fortressActions, getClaims, getDb, getScopedDb, getSubject, getUserId, protectedRoute, replayCookies, setAuthCookies, toSvelteKitHandler, vBody, vParam, vQuery };