@plyaz/types 1.46.3 → 1.46.5

package/dist/auth/signin-flow.d.ts

@@ -0,0 +1,36 @@
+import type { AuthTokens, AuthUser } from "./types";
+export interface SignInCredentials {
+    email: string;
+    password: string;
+    rememberMe?: boolean;
+}
+export interface SignInResult {
+    user: AuthUser;
+    tokens: AuthTokens;
+    requiresMFA?: boolean;
+    mfaToken?: string;
+}
+/** User repository type based on usage */
+export interface UserRepositorySignin {
+    findByEmail(email: string): Promise<AuthUser | null>;
+    findById(userId: string): Promise<AuthUser | null>;
+}
+/** JWT manager type based on usage */
+export interface JWTManagerSignin {
+    generateTokens(userId: string): Promise<AuthTokens>;
+    verifyToken(token: string): Promise<{
+        userId: string;
+    }>;
+}
+/** Session manager type based on usage */
+export interface SessionManagerSignin {
+    createSession(session: {
+        userId: string;
+        expiresAt: Date;
+        metadata?: Record<string, true>;
+    }): Promise<void>;
+}
+/** Password service type based on usage */
+export interface PasswordServiceSignin {
+    verify(password: string, passwordHash: string | undefined): Promise<boolean>;
+}

package/dist/auth/signup-flow.d.ts

@@ -0,0 +1,47 @@
+import type { AuthTokens, AuthUser } from "./types";
+export interface SignUpData {
+    email: string;
+    password: string;
+    firstName?: string;
+    lastName?: string;
+    metadata?: Record<string, string>;
+}
+export interface SignUpResult {
+    user: AuthUser;
+    tokens: AuthTokens;
+    requiresVerification?: boolean;
+}
+/** User repository type based on usage */
+export interface UserRepositorySignUp {
+    findByEmail(email: string): Promise<AuthUser | null>;
+    create(data: {
+        email: string;
+        passwordHash: string;
+        firstName?: string;
+        lastName?: string;
+        metadata?: Record<string, string>;
+        emailVerified: boolean;
+    }): Promise<AuthUser>;
+    findById(userId: string): Promise<AuthUser>;
+    updateEmailVerification(userId: string, verified: boolean): Promise<AuthUser | null>;
+}
+/** JWT manager type based on usage */
+export interface JWTManagerSignUp {
+    generateTokens(userId: string): Promise<AuthTokens>;
+    generateVerificationToken(userId: string): Promise<string>;
+    verifyToken(token: string): Promise<{
+        userId: string;
+    }>;
+}
+/** Password service type based on usage */
+export interface PasswordServiceSignUp {
+    hash(password: string): Promise<string>;
+}
+/** Email service type based on usage */
+export interface EmailService {
+    sendVerificationEmail(args: {
+        to: string;
+        token: string;
+        userId: string;
+    }): Promise<void>;
+}

package/dist/auth/store.d.ts

@@ -0,0 +1,44 @@
+import type { AuthAdapterUser, AuthSession, Tokens } from "./adapter-interface";
+import type { AuthPermissions } from "./client";
+import type { AUTHPROVIDER } from "./enums";
+import type { AuthCredentials, AuthTokens, AuthUser, ConnectedAccount, Session } from "./types";
+export interface AuthState {
+    user: AuthPermissions | null;
+    tokens: AuthTokens | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    session: Session | null;
+    sessionExpiry: Date | null;
+    connectedAccounts: ConnectedAccount[];
+    permissions: string[];
+    roles: string[];
+    lastActivity: Date | null;
+    rememberMe: boolean;
+    error: string | null;
+}
+export interface AuthActions {
+    setUser: (user: AuthUser | null) => void;
+    updateUser: (updates: Partial<AuthUser>) => void;
+    setTokens: (tokens: AuthTokens | null) => void;
+    refreshTokens: () => Promise<void>;
+    setSession: (session: Session | null) => void;
+    updateLastActivity: () => void;
+    setConnectedAccounts: (accounts: ConnectedAccount[]) => void;
+    addConnectedAccount: (account: ConnectedAccount) => void;
+    removeConnectedAccount: (accountId: string) => void;
+    setPermissions: (permissions: string[]) => void;
+    setRoles: (roles: string[]) => void;
+    hasPermission: (permission: string) => boolean;
+    hasRole: (role: string) => boolean;
+    signIn: (provider?: AUTHPROVIDER, credentials?: AuthCredentials) => Promise<{
+        user: AuthAdapterUser;
+        session: AuthSession;
+        tokens: Tokens;
+    }>;
+    signUp: (provider: AUTHPROVIDER, data?: unknown) => Promise<void>;
+    signOut: () => Promise<void>;
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    clearError: () => void;
+    reset: () => void;
+}

package/dist/auth/types.d.ts

@@ -2,6 +2,7 @@ import type { WithExpiration, WithAuthTokens } from '../common/types';
 import type { BaseErrorContext } from '../errors';
 import type { AUTH_ERROR_DEFINITIONS, USER_ROLE_STATUS } from './enums';
 import type { AuthForm } from './schemas';
+import type { JwtPayload } from "jsonwebtoken";
 /**
  * AuthToken Interface.
  * @description Represents an authentication token set returned after a successful login or refresh.
@@ -1187,3 +1188,335 @@ export interface AuthDeviceInfo {
     os: string;
     userAgent: string;
 }
+export interface TokenBlacklistConfig {
+    redisUrl?: string;
+    keyPrefix: string;
+    defaultTTL: number;
+}
+export interface AuthProviderConfig {
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    scopes?: string[];
+}
+export interface AuthenticationProvider {
+    readonly name: string;
+    readonly type: "oauth" | "traditional" | "web3";
+    initialize(config: AuthProviderConfig): Promise<void>;
+    authenticate(credentials: {
+        code: string;
+    }): Promise<{
+        user: AuthUser;
+        tokens: AuthTokens;
+    }>;
+    refreshToken(refreshToken: string): Promise<AuthTokens>;
+    revokeToken(token: string): Promise<void>;
+    getUserProfile(accessToken: string): Promise<AuthUser>;
+}
+export interface RoleRepository {
+    /**
+     * Get all roles assigned to a user
+     * @param userId - User identifier
+     * @returns Array of Role objects
+     */
+    getUserRoles(userId: string): Promise<Role[]>;
+    /**
+     * Get all permissions assigned to a role
+     * @param roleId - Role identifier
+     * @returns Array of Permission objects
+     */
+    getRolePermissions(roleId: string): Promise<Permission[]>;
+}
+export interface GetUserRoleRepository {
+    /**
+     * Get all roles assigned to a user
+     * @param userId - User identifier
+     * @returns Array of Role objects
+     */
+    getUserRoles(userId: string): Promise<Role[]>;
+}
+export interface TypedRequest {
+    user?: {
+        sub?: string;
+        userId?: string;
+    };
+    params?: Record<string, string>;
+    query?: Record<string, string>;
+    body?: Record<string, string>;
+    permissionResult?: unknown;
+}
+/**
+ * Permission metadata interface
+ */
+export interface PermissionMetadata {
+    resource: string;
+    action: string;
+    conditions?: Record<string, string>;
+}
+export interface AuthRequest extends Request {
+    /** Optional session ID extracted from cookies or headers */
+    sessionId?: string;
+}
+export interface SessionMiddlewareConfig {
+    /** Refresh threshold in seconds (default: 300 = 5 minutes) */
+    refreshThreshold: number;
+    /** Cookie options for tokens */
+    cookieOptions: {
+        httpOnly: boolean;
+        secure: boolean;
+        sameSite: "strict" | "lax" | "none";
+        path: string;
+    };
+}
+export interface CookieStoreConfig extends Partial<SessionStoreConfig> {
+    /** Secret key for encryption */
+    secretKey: string;
+    /** Cookie name */
+    cookieName: string;
+    /** Cookie domain */
+    domain?: string;
+    /** Cookie path */
+    path?: string;
+    /** Secure flag (HTTPS only) */
+    secure?: boolean;
+    /** HttpOnly flag */
+    httpOnly?: boolean;
+    /** SameSite policy */
+    sameSite?: "strict" | "lax" | "none";
+}
+/**
+ * User context for session creation
+ */
+export interface UserSessionContext {
+    /** User ID */
+    userId: string;
+    /** User email */
+    email?: string;
+    /** User roles */
+    roles?: string[];
+    /** Additional user metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Session creation data
+ */
+export interface SessionCreationData {
+    /** IP address */
+    ipAddress?: string;
+    /** User agent string */
+    userAgent?: string;
+    /** Device information */
+    deviceInfo?: Record<string, unknown>;
+    /** Additional session metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Enhanced session manager configuration
+ */
+export interface EnhancedSessionManagerConfig {
+    /** Session store implementation */
+    store: SessionStore;
+    /** Default session TTL in seconds */
+    sessionTTL: number;
+    /** Maximum concurrent sessions per user */
+    maxConcurrentSessions: number;
+    /** Enable CSRF protection */
+    enableCSRF: boolean;
+    /** CSRF token TTL in seconds */
+    csrfTTL: number;
+    /** Enable session refresh */
+    enableRefresh: boolean;
+    /** Session refresh threshold (seconds before expiry) */
+    refreshThreshold: number;
+}
+/**
+ * Redis connection configuration
+ */
+export interface RedisConfig {
+    /** Redis host */
+    host: string;
+    /** Redis port */
+    port: number;
+    /** Redis password */
+    password?: string;
+    /** Redis database number */
+    db?: number;
+    /** Connection timeout in milliseconds */
+    connectTimeout?: number;
+    /** Command timeout in milliseconds */
+    commandTimeout?: number;
+    /** Enable TLS */
+    tls?: boolean;
+}
+/**
+ * Redis store configuration
+ */
+export interface RedisStoreConfig extends Partial<SessionStoreConfig> {
+    /** Redis connection configuration */
+    redis: RedisConfig;
+    /** Enable compression for large sessions */
+    compression?: boolean;
+    /** Serialization format */
+    serialization?: "json" | "msgpack";
+}
+/**
+ * Mock Redis client interface for development
+ * In production, this would be replaced with actual Redis client (ioredis, node-redis, etc.)
+ */
+export interface MockRedisClient {
+    set(key: string, value: string, ex: number): Promise<string>;
+    get(key: string): Promise<string | null>;
+    del(key: string): Promise<number>;
+    keys(pattern: string): Promise<string[]>;
+    expire(key: string, seconds: number): Promise<number>;
+    exists(key: string): Promise<number>;
+    scan(cursor: string, match?: string, count?: number): Promise<[string, string[]]>;
+}
+export interface OAuthProfile {
+    id: string;
+    email: string;
+    name: string;
+    avatar?: string;
+    provider: string;
+}
+/**
+ * Refresh token manager configuration
+ */
+export interface RefreshTokenManagerConfig {
+    /** Secret key for signing tokens */
+    secretKey: string;
+    /** Refresh token TTL in seconds */
+    tokenTTL: number;
+    /** Access token TTL in seconds */
+    accessTokenTTL: number;
+    /** Token issuer */
+    issuer: string;
+    /** Token audience */
+    audience: string;
+    /** Enable token rotation */
+    enableRotation: boolean;
+    /** Enable token family tracking */
+    enableFamilyTracking: boolean;
+    /** Maximum token family size */
+    maxFamilySize: number;
+}
+/**
+ * Token pair (access + refresh)
+ */
+export interface TokenPair {
+    /** Access token */
+    accessToken: string;
+    /** Refresh token */
+    refreshToken: string;
+    /** Access token expiration */
+    accessTokenExpiresAt: Date;
+    /** Refresh token expiration */
+    refreshTokenExpiresAt: Date;
+}
+/**
+ * Refresh token payload
+ */
+export interface RefreshTokenPayload {
+    /** User ID */
+    sub: string;
+    /** Session ID */
+    sessionId: string;
+    /** Token family ID (for rotation tracking) */
+    family?: string;
+    /** Token generation number */
+    generation?: number;
+    /** Token type */
+    type: "refresh";
+    /** Issued at */
+    iat: number;
+    /** Expires at */
+    exp: number;
+    /** Issuer */
+    iss: string;
+    /** Audience */
+    aud: string;
+}
+/**
+ * Access token payload
+ */
+export interface AccessTokenPayload {
+    /** User ID */
+    sub: string;
+    /** Session ID */
+    sessionId: string;
+    /** User roles */
+    roles?: string[];
+    /** User permissions */
+    permissions?: string[];
+    /** Token type */
+    type: "access";
+    /** Issued at */
+    iat: number;
+    /** Expires at */
+    exp: number;
+    /** Issuer */
+    iss: string;
+    /** Audience */
+    aud: string;
+}
+/**
+ * Token family for rotation tracking
+ */
+export interface TokenFamily {
+    /** Family ID */
+    id: string;
+    /** User ID */
+    userId: string;
+    /** Session ID */
+    sessionId: string;
+    /** Current generation */
+    generation: number;
+    /** Created at */
+    createdAt: Date;
+    /** Last used at */
+    lastUsedAt: Date;
+}
+export interface TokenValidatorConfig {
+    /** Public key for signature verification */
+    publicKey: string;
+    /** Expected token issuer */
+    issuer: string;
+    /** Expected token audience */
+    audience: string;
+    /** Algorithm for verification */
+    algorithm?: string;
+    /** Clock tolerance in seconds */
+    clockTolerance?: number;
+    /** Enable blacklist checking */
+    enableBlacklist?: boolean;
+}
+/**
+ * Validated token payload
+ */
+export interface ValidatedTokenPayload extends JwtPayload {
+    /** User ID (subject) */
+    sub: string;
+    /** Session ID */
+    sessionId?: string;
+    /** User roles */
+    roles?: string[];
+    /** User permissions */
+    permissions?: string[];
+    /** Token type */
+    type?: "access" | "refresh";
+}
+/**
+ * Token validation result
+ */
+export interface TokenValidationResult {
+    /** Validation success */
+    valid: boolean;
+    /** Decoded payload (if valid) */
+    payload?: ValidatedTokenPayload;
+    /** Error details (if invalid) */
+    error?: {
+        code: string;
+        message: string;
+        details?: unknown;
+    };
+}

package/dist/devtools/types.d.ts

@@ -11,7 +11,7 @@ import type { CorePlyazConfig } from '../core';
 /**
  * Available devtools tab identifiers
  */
-export type DevtoolsTab = 'stores' | 'actions' | 'api' | 'streaming' | 'security' | 'compliance' | 'accessibility' | 'services' | 'errors' | 'events' | 'uploads' | 'observability' | 'config' | 'storage' | 'playground' | 'runner' | 'flags' | 'mocking' | 'explorer' | 'ssr' | 'routes' | 'i18n' | 'react' | 'console' | 'shortcuts';
+export type DevtoolsTab = 'stores' | 'actions' | 'api' | 'streaming' | 'security' | 'compliance' | 'accessibility' | 'services' | 'errors' | 'events' | 'uploads' | 'observability' | 'config' | 'storage' | 'playground' | 'runner' | 'flags' | 'mocking' | 'explorer' | 'types' | 'ssr' | 'routes' | 'i18n' | 'react' | 'console' | 'shortcuts';
 /**
  * Tab group configuration
  */