@qyh213/easyauth-client 1.0.0-beta.1

package/dist/next.mjs

@@ -0,0 +1,124 @@
+import {
+  EasyAuthClient,
+  EasyAuthError,
+  LocalStorageTokenStorage,
+  MemoryTokenStorage,
+  ScopeError
+} from "./chunk-H65ZLXQJ.mjs";
+
+// src/next.tsx
+import { NextResponse } from "next/server";
+import { jsx } from "react/jsx-runtime";
+function createEasyAuthMiddleware(options) {
+  return async function middleware(request) {
+    const {
+      baseUrl,
+      apiKey,
+      protectedPaths = [],
+      scopedPaths = {},
+      publicPaths = [],
+      loginPath = "/login",
+      forbiddenPath = "/forbidden"
+    } = options;
+    const pathname = request.nextUrl.pathname;
+    if (publicPaths.some((p) => pathname.startsWith(p))) {
+      return NextResponse.next();
+    }
+    const token = request.cookies.get("easy_auth_token")?.value || request.headers.get("Authorization")?.replace("Bearer ", "");
+    if (!token) {
+      if (protectedPaths.some((p) => pathname.startsWith(p))) {
+        return NextResponse.redirect(new URL(loginPath, request.url));
+      }
+      if (Object.keys(scopedPaths).some((p) => pathname.startsWith(p))) {
+        return NextResponse.redirect(new URL(loginPath, request.url));
+      }
+      return NextResponse.next();
+    }
+    const client = new EasyAuthClient({ baseUrl, apiKey });
+    const serviceId = apiKey.split(".")[0];
+    try {
+      const introspectResult = await client.introspect({
+        serviceId,
+        token
+      });
+      if (!introspectResult.valid) {
+        if (protectedPaths.some((p) => pathname.startsWith(p)) || Object.keys(scopedPaths).some((p) => pathname.startsWith(p))) {
+          return NextResponse.redirect(new URL(loginPath, request.url));
+        }
+        return NextResponse.next();
+      }
+      for (const [pathPattern, requiredScopes] of Object.entries(scopedPaths)) {
+        if (pathname.startsWith(pathPattern)) {
+          const hasScopes = requiredScopes.every(
+            (scope) => introspectResult.scopes?.includes(scope)
+          );
+          if (!hasScopes) {
+            return NextResponse.redirect(new URL(forbiddenPath, request.url));
+          }
+        }
+      }
+      const requestHeaders = new Headers(request.headers);
+      requestHeaders.set("x-user-id", introspectResult.userId || "");
+      requestHeaders.set("x-user-email", introspectResult.email || "");
+      requestHeaders.set("x-user-scopes", JSON.stringify(introspectResult.scopes || []));
+      return NextResponse.next({
+        request: {
+          headers: requestHeaders
+        }
+      });
+    } catch (error) {
+      console.error("Auth middleware error:", error);
+      if (protectedPaths.some((p) => pathname.startsWith(p)) || Object.keys(scopedPaths).some((p) => pathname.startsWith(p))) {
+        return NextResponse.redirect(new URL(loginPath, request.url));
+      }
+      return NextResponse.next();
+    }
+  };
+}
+function withScope(Component, _requiredScopes, _config) {
+  return function WithScopeWrapper(props) {
+    return /* @__PURE__ */ jsx(Component, { ...props });
+  };
+}
+async function validateScopes(request, options) {
+  const { baseUrl, apiKey, requiredScopes } = options;
+  const authHeader = request.headers.get("Authorization");
+  const token = authHeader?.replace("Bearer ", "");
+  if (!token) {
+    return { valid: false, error: "No token provided", status: 401 };
+  }
+  const client = new EasyAuthClient({ baseUrl, apiKey });
+  const serviceId = apiKey.split(".")[0];
+  try {
+    const result = await client.introspect({
+      serviceId,
+      token,
+      requiredScopes
+    });
+    if (!result.valid) {
+      return {
+        valid: false,
+        error: result.error || "Invalid token",
+        status: result.error?.includes("scope") ? 403 : 401
+      };
+    }
+    return {
+      valid: true,
+      userId: result.userId,
+      email: result.email,
+      scopes: result.scopes
+    };
+  } catch (error) {
+    return { valid: false, error: "Validation failed", status: 500 };
+  }
+}
+export {
+  EasyAuthClient,
+  EasyAuthError,
+  LocalStorageTokenStorage,
+  MemoryTokenStorage,
+  ScopeError,
+  createEasyAuthMiddleware,
+  validateScopes,
+  withScope
+};

package/dist/react.d.mts

@@ -0,0 +1,68 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { e as EasyAuthConfig, T as TokenStorage, E as EasyAuthClient, U as User, V as ValidationResult } from './client-RPDHpVsj.mjs';
+export { A as ApiKey, a as AuthToken, C as CreateApiKeyRequest, b as CreateApiKeyResponse, c as CreateScopeRequest, d as CreateUserRequest, f as EasyAuthError, I as IntrospectRequest, g as IntrospectResponse, L as LocalStorageTokenStorage, h as LoginCredentials, M as MemoryTokenStorage, O as OnboardRequest, i as OnboardResponse, R as RegisterWebhookRequest, S as Scope, j as ScopeError, k as Service, l as UserListResponse, W as Webhook } from './client-RPDHpVsj.mjs';
+
+interface EasyAuthContextValue {
+    client: EasyAuthClient;
+    isAuthenticated: boolean;
+    user: User | null;
+    isLoading: boolean;
+    login: (email: string, password: string) => Promise<void>;
+    logout: () => Promise<void>;
+    validate: () => Promise<ValidationResult>;
+}
+interface EasyAuthProviderProps {
+    config: EasyAuthConfig;
+    tokenStorage?: TokenStorage;
+    children: ReactNode;
+    /**
+     * Validate token on mount and periodically
+     */
+    validateOnMount?: boolean;
+    /**
+     * Validation interval in milliseconds (default: 5 minutes)
+     */
+    validationInterval?: number;
+}
+declare function EasyAuthProvider({ config, tokenStorage, children, validateOnMount, validationInterval, }: EasyAuthProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Access the Easy Auth context
+ */
+declare function useEasyAuth(): EasyAuthContextValue;
+/**
+ * Get the Easy Auth client instance
+ */
+declare function useEasyAuthClient(): EasyAuthClient;
+/**
+ * Check if user is authenticated
+ */
+declare function useIsAuthenticated(): boolean;
+/**
+ * Get current user
+ */
+declare function useUser(): User | null;
+/**
+ * Login/logout methods
+ */
+declare function useAuthActions(): {
+    login: (email: string, password: string) => Promise<void>;
+    logout: () => Promise<void>;
+    isLoading: boolean;
+};
+interface ProtectedProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+/**
+ * Component that only renders children when authenticated
+ */
+declare function Protected({ children, fallback }: ProtectedProps): react_jsx_runtime.JSX.Element | null;
+interface LoginFormProps {
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+declare function LoginForm({ onSuccess, onError, className }: LoginFormProps): react_jsx_runtime.JSX.Element;
+
+export { EasyAuthClient, EasyAuthConfig, EasyAuthProvider, LoginForm, Protected, TokenStorage, User, ValidationResult, useAuthActions, useEasyAuth, useEasyAuthClient, useIsAuthenticated, useUser };

package/dist/react.d.ts

@@ -0,0 +1,68 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { e as EasyAuthConfig, T as TokenStorage, E as EasyAuthClient, U as User, V as ValidationResult } from './client-RPDHpVsj.js';
+export { A as ApiKey, a as AuthToken, C as CreateApiKeyRequest, b as CreateApiKeyResponse, c as CreateScopeRequest, d as CreateUserRequest, f as EasyAuthError, I as IntrospectRequest, g as IntrospectResponse, L as LocalStorageTokenStorage, h as LoginCredentials, M as MemoryTokenStorage, O as OnboardRequest, i as OnboardResponse, R as RegisterWebhookRequest, S as Scope, j as ScopeError, k as Service, l as UserListResponse, W as Webhook } from './client-RPDHpVsj.js';
+
+interface EasyAuthContextValue {
+    client: EasyAuthClient;
+    isAuthenticated: boolean;
+    user: User | null;
+    isLoading: boolean;
+    login: (email: string, password: string) => Promise<void>;
+    logout: () => Promise<void>;
+    validate: () => Promise<ValidationResult>;
+}
+interface EasyAuthProviderProps {
+    config: EasyAuthConfig;
+    tokenStorage?: TokenStorage;
+    children: ReactNode;
+    /**
+     * Validate token on mount and periodically
+     */
+    validateOnMount?: boolean;
+    /**
+     * Validation interval in milliseconds (default: 5 minutes)
+     */
+    validationInterval?: number;
+}
+declare function EasyAuthProvider({ config, tokenStorage, children, validateOnMount, validationInterval, }: EasyAuthProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Access the Easy Auth context
+ */
+declare function useEasyAuth(): EasyAuthContextValue;
+/**
+ * Get the Easy Auth client instance
+ */
+declare function useEasyAuthClient(): EasyAuthClient;
+/**
+ * Check if user is authenticated
+ */
+declare function useIsAuthenticated(): boolean;
+/**
+ * Get current user
+ */
+declare function useUser(): User | null;
+/**
+ * Login/logout methods
+ */
+declare function useAuthActions(): {
+    login: (email: string, password: string) => Promise<void>;
+    logout: () => Promise<void>;
+    isLoading: boolean;
+};
+interface ProtectedProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+/**
+ * Component that only renders children when authenticated
+ */
+declare function Protected({ children, fallback }: ProtectedProps): react_jsx_runtime.JSX.Element | null;
+interface LoginFormProps {
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+    className?: string;
+}
+declare function LoginForm({ onSuccess, onError, className }: LoginFormProps): react_jsx_runtime.JSX.Element;
+
+export { EasyAuthClient, EasyAuthConfig, EasyAuthProvider, LoginForm, Protected, TokenStorage, User, ValidationResult, useAuthActions, useEasyAuth, useEasyAuthClient, useIsAuthenticated, useUser };