@revealui/auth 0.0.1-pre.0 → 0.2.1

package/dist/server/password-reset.js

@@ -0,0 +1,232 @@
+/**
+ * Password Reset Utilities
+ *
+ * Token generation and validation for password reset flows.
+ * Tokens are stored in the database with expiry and single-use enforcement.
+ */
+import crypto from 'node:crypto';
+import { logger } from '@revealui/core/observability/logger';
+import { getClient } from '@revealui/db/client';
+import { passwordResetTokens, sessions, users } from '@revealui/db/schema';
+import bcrypt from 'bcryptjs';
+import { and, eq, gt, isNull } from 'drizzle-orm';
+const TOKEN_EXPIRY_MS = 15 * 60 * 1000; // 15 minutes
+/**
+ * Hash a token using HMAC-SHA256 with a per-token salt.
+ * The salt is stored in the DB alongside the hash; this defeats rainbow
+ * table attacks even if the database is fully compromised.
+ *
+ * @param token - Plain-text token
+ * @param salt  - 16-byte random salt (hex string)
+ */
+function hashToken(token, salt) {
+    return crypto.createHmac('sha256', salt).update(token).digest('hex');
+}
+/**
+ * Generate a 16-byte random salt (hex string).
+ */
+function generateSalt() {
+    return crypto.randomBytes(16).toString('hex');
+}
+/**
+ * Generates a password reset token for a user
+ *
+ * @param email - User email
+ * @returns Reset token and expiry
+ */
+export async function generatePasswordResetToken(email) {
+    try {
+        const db = getClient();
+        // Find user by email
+        const [user] = await db.select().from(users).where(eq(users.email, email)).limit(1);
+        if (!user) {
+            // Don't reveal if user exists (security best practice)
+            return {
+                success: true,
+                token: crypto.randomBytes(32).toString('hex'),
+            };
+        }
+        // Invalidate any existing unused reset tokens for this user before creating a new one.
+        // This limits active tokens to one per user, preventing table accumulation that would
+        // slow the time-bounded full-table scan in validatePasswordResetToken.
+        await db
+            .update(passwordResetTokens)
+            .set({ usedAt: new Date() })
+            .where(and(eq(passwordResetTokens.userId, user.id), isNull(passwordResetTokens.usedAt)));
+        // Generate secure token with per-token salt
+        const token = crypto.randomBytes(32).toString('hex');
+        const tokenSalt = generateSalt();
+        const tokenHash = hashToken(token, tokenSalt);
+        const expiresAt = new Date(Date.now() + TOKEN_EXPIRY_MS);
+        const id = crypto.randomUUID();
+        // Store hashed token + salt in database (salt is not secret, just unique)
+        await db.insert(passwordResetTokens).values({
+            id,
+            userId: user.id,
+            tokenHash,
+            tokenSalt,
+            expiresAt,
+        });
+        return {
+            success: true,
+            token,
+            tokenId: id,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const isSchemaError = errorMessage.includes('column') ||
+            errorMessage.includes('relation') ||
+            errorMessage.includes('does not exist');
+        if (isSchemaError) {
+            logger.error('Password reset token generation failed due to DB schema mismatch. ' +
+                'Ensure migration 0006_add_password_reset_token_salt.sql has been applied.', error instanceof Error ? error : new Error(String(error)));
+        }
+        else {
+            logger.error('Error generating password reset token', error instanceof Error ? error : new Error(String(error)));
+        }
+        return {
+            success: false,
+            error: 'Failed to generate reset token',
+        };
+    }
+}
+/**
+ * Validates a password reset token
+ *
+ * Uses O(1) lookup by token ID, then verifies the token hash with timingSafeEqual
+ * against the single matching row.
+ *
+ * @param tokenId - Token row ID (from the reset URL)
+ * @param token - Reset token (plain text, from the reset URL)
+ * @returns User ID if valid, null otherwise
+ */
+export async function validatePasswordResetToken(tokenId, token) {
+    try {
+        const db = getClient();
+        // O(1) lookup by primary key, filtered to unexpired and unused tokens
+        const [entry] = await db
+            .select()
+            .from(passwordResetTokens)
+            .where(and(eq(passwordResetTokens.id, tokenId), gt(passwordResetTokens.expiresAt, new Date()), isNull(passwordResetTokens.usedAt)))
+            .limit(1);
+        if (!entry) {
+            return null;
+        }
+        // Verify the token hash using timing-safe comparison
+        const expectedHash = hashToken(token, entry.tokenSalt);
+        const expectedBuf = Buffer.from(expectedHash);
+        const actualBuf = Buffer.from(entry.tokenHash);
+        if (expectedBuf.length === actualBuf.length && crypto.timingSafeEqual(expectedBuf, actualBuf)) {
+            return entry.userId;
+        }
+        return null;
+    }
+    catch (error) {
+        logger.error('Error validating password reset token', error instanceof Error ? error : new Error(String(error)));
+        return null;
+    }
+}
+/**
+ * Resets password using a token
+ *
+ * Uses O(1) lookup by token ID, then verifies the token hash.
+ *
+ * @param tokenId - Token row ID (from the reset URL)
+ * @param token - Reset token (plain text, from the reset URL)
+ * @param newPassword - New password
+ * @returns Success result
+ */
+export async function resetPasswordWithToken(tokenId, token, newPassword) {
+    try {
+        const db = getClient();
+        // O(1) lookup by primary key, filtered to unexpired and unused tokens
+        const [entry] = await db
+            .select()
+            .from(passwordResetTokens)
+            .where(and(eq(passwordResetTokens.id, tokenId), gt(passwordResetTokens.expiresAt, new Date()), isNull(passwordResetTokens.usedAt)))
+            .limit(1);
+        if (!entry) {
+            return {
+                success: false,
+                error: 'Invalid or expired reset token',
+            };
+        }
+        // Verify the token hash using timing-safe comparison
+        const expectedHash = hashToken(token, entry.tokenSalt);
+        const expectedBuf = Buffer.from(expectedHash);
+        const actualBuf = Buffer.from(entry.tokenHash);
+        if (!(expectedBuf.length === actualBuf.length && crypto.timingSafeEqual(expectedBuf, actualBuf))) {
+            return {
+                success: false,
+                error: 'Invalid or expired reset token',
+            };
+        }
+        // Validate password strength
+        const { validatePasswordStrength } = await import('./password-validation.js');
+        const passwordValidation = validatePasswordStrength(newPassword);
+        if (!passwordValidation.valid) {
+            return {
+                success: false,
+                error: passwordValidation.errors.join('. '),
+            };
+        }
+        // Hash new password
+        const password = await bcrypt.hash(newPassword, 12);
+        // Update user password
+        await db.update(users).set({ password }).where(eq(users.id, entry.userId));
+        // Invalidate all existing sessions for this user so any attacker who had
+        // a compromised session can no longer use it after the password change.
+        await db.delete(sessions).where(eq(sessions.userId, entry.userId));
+        // Mark token as used (single-use enforcement)
+        await db
+            .update(passwordResetTokens)
+            .set({ usedAt: new Date() })
+            .where(eq(passwordResetTokens.id, entry.id));
+        return {
+            success: true,
+        };
+    }
+    catch (error) {
+        logger.error('Error resetting password', error instanceof Error ? error : new Error(String(error)));
+        return {
+            success: false,
+            error: 'Failed to reset password',
+        };
+    }
+}
+/**
+ * Invalidates a password reset token
+ *
+ * Uses O(1) lookup by token ID, then verifies the token hash before marking as used.
+ *
+ * @param tokenId - Token row ID (from the reset URL)
+ * @param token - Reset token (plain text, from the reset URL)
+ */
+export async function invalidatePasswordResetToken(tokenId, token) {
+    try {
+        const db = getClient();
+        // O(1) lookup by primary key
+        const [entry] = await db
+            .select()
+            .from(passwordResetTokens)
+            .where(and(eq(passwordResetTokens.id, tokenId), gt(passwordResetTokens.expiresAt, new Date()), isNull(passwordResetTokens.usedAt)))
+            .limit(1);
+        if (!entry) {
+            return;
+        }
+        // Verify the token hash before invalidating
+        const expectedHash = hashToken(token, entry.tokenSalt);
+        const expectedBuf = Buffer.from(expectedHash);
+        const actualBuf = Buffer.from(entry.tokenHash);
+        if (expectedBuf.length === actualBuf.length && crypto.timingSafeEqual(expectedBuf, actualBuf)) {
+            await db
+                .update(passwordResetTokens)
+                .set({ usedAt: new Date() })
+                .where(eq(passwordResetTokens.id, entry.id));
+        }
+    }
+    catch (error) {
+        logger.error('Error invalidating password reset token', error instanceof Error ? error : new Error(String(error)));
+    }
+}

package/dist/server/password-validation.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Password Validation Utilities
+ *
+ * Password strength validation and requirements.
+ */
+export interface PasswordValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+/**
+ * Validates password strength
+ *
+ * @param password - Password to validate
+ * @returns Validation result with errors
+ */
+export declare function validatePasswordStrength(password: string): PasswordValidationResult;
+/**
+ * Checks if password meets minimum requirements (length only)
+ * Used for less strict validation
+ *
+ * @param password - Password to check
+ * @returns True if meets minimum requirements
+ */
+export declare function meetsMinimumPasswordRequirements(password: string): boolean;
+//# sourceMappingURL=password-validation.d.ts.map

package/dist/server/password-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-validation.d.ts","sourceRoot":"","sources":["../../src/server/password-validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,GAAG,wBAAwB,CAgCnF;AAED;;;;;;GAMG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1E"}

package/dist/server/password-validation.js

@@ -0,0 +1,47 @@
+/**
+ * Password Validation Utilities
+ *
+ * Password strength validation and requirements.
+ */
+/**
+ * Validates password strength
+ *
+ * @param password - Password to validate
+ * @returns Validation result with errors
+ */
+export function validatePasswordStrength(password) {
+    const errors = [];
+    if (password.length < 8) {
+        errors.push('Password must be at least 8 characters long');
+    }
+    if (password.length > 128) {
+        errors.push('Password must be less than 128 characters');
+    }
+    if (!/[a-z]/.test(password)) {
+        errors.push('Password must contain at least one lowercase letter');
+    }
+    if (!/[A-Z]/.test(password)) {
+        errors.push('Password must contain at least one uppercase letter');
+    }
+    if (!/[0-9]/.test(password)) {
+        errors.push('Password must contain at least one number');
+    }
+    // Optional: special characters (not too strict)
+    // if (!/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password)) {
+    //   errors.push('Password must contain at least one special character')
+    // }
+    return {
+        valid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Checks if password meets minimum requirements (length only)
+ * Used for less strict validation
+ *
+ * @param password - Password to check
+ * @returns True if meets minimum requirements
+ */
+export function meetsMinimumPasswordRequirements(password) {
+    return password.length >= 8 && password.length <= 128;
+}

package/dist/server/providers/github.d.ts

@@ -0,0 +1,14 @@
+/**
+ * GitHub OAuth Provider
+ *
+ * Uses native fetch — no additional npm dependencies.
+ * Scopes: read:user user:email
+ *
+ * Note: GitHub may return null email if user has set it private.
+ * In that case we fetch from /user/emails and pick the primary verified one.
+ */
+import type { ProviderUser } from '../oauth.js';
+export declare function buildAuthUrl(clientId: string, redirectUri: string, state: string): string;
+export declare function exchangeCode(code: string, redirectUri: string): Promise<string>;
+export declare function fetchUser(accessToken: string): Promise<ProviderUser>;
+//# sourceMappingURL=github.d.ts.map

package/dist/server/providers/github.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"github.d.ts","sourceRoot":"","sources":["../../../src/server/providers/github.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAOzF;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA4BrF;AAED,wBAAsB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA2C1E"}

package/dist/server/providers/github.js

@@ -0,0 +1,73 @@
+/**
+ * GitHub OAuth Provider
+ *
+ * Uses native fetch — no additional npm dependencies.
+ * Scopes: read:user user:email
+ *
+ * Note: GitHub may return null email if user has set it private.
+ * In that case we fetch from /user/emails and pick the primary verified one.
+ */
+export function buildAuthUrl(clientId, redirectUri, state) {
+    const url = new URL('https://github.com/login/oauth/authorize');
+    url.searchParams.set('client_id', clientId);
+    url.searchParams.set('redirect_uri', redirectUri);
+    url.searchParams.set('scope', 'read:user user:email');
+    url.searchParams.set('state', state);
+    return url.toString();
+}
+export async function exchangeCode(code, redirectUri) {
+    const response = await fetch('https://github.com/login/oauth/access_token', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            // biome-ignore lint/style/useNamingConvention: HTTP header names are case-sensitive per RFC 7230
+            Accept: 'application/json',
+        },
+        body: new URLSearchParams({
+            code,
+            client_id: process.env.GITHUB_CLIENT_ID ?? '',
+            client_secret: process.env.GITHUB_CLIENT_SECRET ?? '',
+            redirect_uri: redirectUri,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`GitHub token exchange failed: ${response.status}`);
+    }
+    const data = (await response.json());
+    if (data.error) {
+        throw new Error(`GitHub token exchange error: ${data.error}`);
+    }
+    if (!data.access_token || typeof data.access_token !== 'string') {
+        throw new Error('GitHub token exchange returned no access_token');
+    }
+    return data.access_token;
+}
+export async function fetchUser(accessToken) {
+    const headers = {
+        // biome-ignore lint/style/useNamingConvention: HTTP header names are case-sensitive per RFC 7230
+        Authorization: `Bearer ${accessToken}`,
+        // biome-ignore lint/style/useNamingConvention: HTTP header names are case-sensitive per RFC 7230
+        Accept: 'application/vnd.github+json',
+    };
+    const userResponse = await fetch('https://api.github.com/user', { headers });
+    if (!userResponse.ok) {
+        throw new Error(`GitHub user fetch failed: ${userResponse.status}`);
+    }
+    const user = (await userResponse.json());
+    let email = user.email ?? null;
+    // Fetch emails if not public
+    if (!email) {
+        const emailsResponse = await fetch('https://api.github.com/user/emails', { headers });
+        if (emailsResponse.ok) {
+            const emails = (await emailsResponse.json());
+            const primary = emails.find((e) => e.primary && e.verified);
+            email = primary?.email ?? null;
+        }
+    }
+    return {
+        id: String(user.id),
+        email,
+        name: user.name ?? user.login,
+        avatarUrl: user.avatar_url ?? null,
+    };
+}

package/dist/server/providers/google.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Google OAuth 2.0 Provider
+ *
+ * Uses native fetch — no additional npm dependencies.
+ * Scopes: openid email profile
+ */
+import type { ProviderUser } from '../oauth.js';
+export declare function buildAuthUrl(clientId: string, redirectUri: string, state: string): string;
+export declare function exchangeCode(code: string, redirectUri: string): Promise<string>;
+export declare function fetchUser(accessToken: string): Promise<ProviderUser>;
+//# sourceMappingURL=google.d.ts.map

package/dist/server/providers/google.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../src/server/providers/google.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CASzF;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAsBrF;AAED,wBAAsB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAuB1E"}

package/dist/server/providers/google.js

@@ -0,0 +1,53 @@
+/**
+ * Google OAuth 2.0 Provider
+ *
+ * Uses native fetch — no additional npm dependencies.
+ * Scopes: openid email profile
+ */
+export function buildAuthUrl(clientId, redirectUri, state) {
+    const url = new URL('https://accounts.google.com/o/oauth2/v2/auth');
+    url.searchParams.set('client_id', clientId);
+    url.searchParams.set('redirect_uri', redirectUri);
+    url.searchParams.set('response_type', 'code');
+    url.searchParams.set('scope', 'openid email profile');
+    url.searchParams.set('state', state);
+    url.searchParams.set('access_type', 'online');
+    return url.toString();
+}
+export async function exchangeCode(code, redirectUri) {
+    const response = await fetch('https://oauth2.googleapis.com/token', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            code,
+            client_id: process.env.GOOGLE_CLIENT_ID ?? '',
+            client_secret: process.env.GOOGLE_CLIENT_SECRET ?? '',
+            redirect_uri: redirectUri,
+            grant_type: 'authorization_code',
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Google token exchange failed: ${response.status}`);
+    }
+    const data = (await response.json());
+    if (!data.access_token || typeof data.access_token !== 'string') {
+        throw new Error('Google token exchange returned no access_token');
+    }
+    return data.access_token;
+}
+export async function fetchUser(accessToken) {
+    const response = await fetch('https://openidconnect.googleapis.com/v1/userinfo', {
+        // biome-ignore lint/style/useNamingConvention: HTTP header names are case-sensitive per RFC 7230
+        headers: { Authorization: `Bearer ${accessToken}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Google userinfo fetch failed: ${response.status}`);
+    }
+    const data = (await response.json());
+    return {
+        id: data.sub,
+        email: data.email ?? null,
+        name: data.name ?? 'Google User',
+        avatarUrl: data.picture ?? null,
+    };
+}

package/dist/server/providers/vercel.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Vercel OAuth Provider
+ *
+ * Uses native fetch — no additional npm dependencies.
+ * No scopes required — Vercel uses full access by default.
+ */
+import type { ProviderUser } from '../oauth.js';
+export declare function buildAuthUrl(clientId: string, redirectUri: string, state: string): string;
+export declare function exchangeCode(code: string, redirectUri: string): Promise<string>;
+export declare function fetchUser(accessToken: string): Promise<ProviderUser>;
+//# sourceMappingURL=vercel.d.ts.map

package/dist/server/providers/vercel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vercel.d.ts","sourceRoot":"","sources":["../../../src/server/providers/vercel.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMzF;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkBrF;AAED,wBAAsB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CA2B1E"}

package/dist/server/providers/vercel.js

@@ -0,0 +1,47 @@
+/**
+ * Vercel OAuth Provider
+ *
+ * Uses native fetch — no additional npm dependencies.
+ * No scopes required — Vercel uses full access by default.
+ */
+export function buildAuthUrl(clientId, redirectUri, state) {
+    const url = new URL('https://vercel.com/oauth/authorize');
+    url.searchParams.set('client_id', clientId);
+    url.searchParams.set('redirect_uri', redirectUri);
+    url.searchParams.set('state', state);
+    return url.toString();
+}
+export async function exchangeCode(code, redirectUri) {
+    const response = await fetch('https://api.vercel.com/v2/oauth/access_token', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams({
+            code,
+            client_id: process.env.VERCEL_CLIENT_ID ?? '',
+            client_secret: process.env.VERCEL_CLIENT_SECRET ?? '',
+            redirect_uri: redirectUri,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Vercel token exchange failed: ${response.status}`);
+    }
+    const data = (await response.json());
+    return data.access_token;
+}
+export async function fetchUser(accessToken) {
+    const response = await fetch('https://api.vercel.com/v2/user', {
+        // biome-ignore lint/style/useNamingConvention: HTTP header names are case-sensitive per RFC 7230
+        headers: { Authorization: `Bearer ${accessToken}` },
+    });
+    if (!response.ok) {
+        throw new Error(`Vercel user fetch failed: ${response.status}`);
+    }
+    const data = (await response.json());
+    const u = data.user;
+    return {
+        id: u.id,
+        email: u.email,
+        name: u.name ?? u.username ?? 'Vercel User',
+        avatarUrl: u.avatar ? `https://avatar.vercel.sh/${u.avatar}` : null,
+    };
+}

package/dist/server/rate-limit.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Rate Limiting Utilities
+ *
+ * Rate limiting for authentication endpoints using storage abstraction.
+ * Supports in-memory (dev), Redis (production), or database (fallback).
+ */
+/**
+ * Rate limit configuration
+ */
+export interface RateLimitConfig {
+    maxAttempts: number;
+    windowMs: number;
+    blockDurationMs?: number;
+}
+/**
+ * Checks if an action should be rate limited
+ *
+ * @param key - Rate limit key (e.g., email, IP address)
+ * @param config - Rate limit configuration
+ * @returns Rate limit result
+ */
+export declare function checkRateLimit(key: string, config?: RateLimitConfig): Promise<{
+    allowed: boolean;
+    remaining: number;
+    resetAt: number;
+}>;
+/**
+ * Resets rate limit for a key
+ *
+ * @param key - Rate limit key
+ */
+export declare function resetRateLimit(key: string): Promise<void>;
+/**
+ * Gets rate limit status for a key
+ *
+ * @param key - Rate limit key
+ * @param config - Rate limit configuration
+ * @returns Rate limit status
+ */
+export declare function getRateLimitStatus(key: string, config?: RateLimitConfig): Promise<{
+    count: number;
+    remaining: number;
+    resetAt: number;
+}>;
+//# sourceMappingURL=rate-limit.d.ts.map

package/dist/server/rate-limit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limit.d.ts","sourceRoot":"","sources":["../../src/server/rate-limit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AAqCD;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,eAAgC,GACvC,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAuDnE;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI/D;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,eAAgC,GACvC,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAqBhE"}