@payez/next-mvp 4.0.49 → 4.1.1

package/dist/server/auth.d.ts

@@ -5,16 +5,6 @@
  * getAuthInstance(); use getSession(req) for the request-scoped session.
  */
 import 'server-only';
-import { type SessionData } from '../lib/session-store';
-export type IdpTokenResult = {
-    success: true;
-    accessToken: string;
-    sessionData: SessionData;
-} | {
-    success: false;
-    error: 'NO_SESSION' | 'NO_TOKEN';
-    terminal: true;
-};
 /**
  * Get the initialized Better Auth instance (singleton).
  */
@@ -55,7 +45,102 @@ export declare function getAuthInstance(): Promise<import("better-auth/types").A
                 handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
             }[];
         };
-    }];
+    }, ...{
+        id: "magic-link";
+        endpoints: {
+            signInMagicLink: import("better-call").StrictEndpoint<"/sign-in/magic-link", {
+                method: "POST";
+                requireHeaders: true;
+                body: import("zod").ZodObject<{
+                    email: import("zod").ZodEmail;
+                    name: import("zod").ZodOptional<import("zod").ZodString>;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    newUserCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    errorCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+                }, import("better-auth/*").$strip>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                status: boolean;
+            }>;
+            magicLinkVerify: import("better-call").StrictEndpoint<"/magic-link/verify", {
+                method: "GET";
+                query: import("zod").ZodObject<{
+                    token: import("zod").ZodString;
+                    callbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    errorCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                    newUserCallbackURL: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("better-auth/*").$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>)[];
+                requireHeaders: true;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            }, {
+                token: string;
+                user: {
+                    id: string;
+                    createdAt: Date;
+                    updatedAt: Date;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image?: string | null | undefined;
+                };
+            }>;
+        };
+        rateLimit: {
+            pathMatcher(path: string): boolean;
+            window: number;
+            max: number;
+        }[];
+        options: import("better-auth/plugins/magic-link").MagicLinkOptions;
+    }[]];
 }>>;
 /**
  * Get the current session from a request.
@@ -64,20 +149,6 @@ export declare function getAuthInstance(): Promise<import("better-auth/types").A
  * Returns the session object or null if not authenticated.
  */
 export declare function getSession(request?: Request): Promise<any>;
-/**
- * Get normalized session data for the current request.
- *
- * This prefers the app's Redis session because it carries the canonical
- * IDP token, roles, and tenant-specific user identity used by app routes.
- */
-export declare function getSessionData(request?: Request): Promise<SessionData | null>;
-/**
- * Get the current request's IDP access token without triggering a refresh.
- *
- * Use this for routes that only need the currently-issued bearer token and
- * should fail closed instead of performing token lifecycle work.
- */
-export declare function getIdpToken(request?: Request): Promise<IdpTokenResult>;
 /**
  * Get the current session, throwing if not authenticated.
  * Use in API handlers that require auth.

package/dist/server/auth.js

@@ -5,67 +5,48 @@
  * All server-side auth flows go through the Better Auth instance returned by
  * getAuthInstance(); use getSession(req) for the request-scoped session.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAuthInstance = getAuthInstance;
 exports.getSession = getSession;
-exports.getSessionData = getSessionData;
-exports.getIdpToken = getIdpToken;
 exports.requireSession = requireSession;
 require("server-only");
 const better_auth_1 = require("../auth/better-auth");
 const idp_client_config_1 = require("../lib/idp-client-config");
-const session_store_1 = require("../lib/session-store");
 let authInstance = null;
 let authInitPromise = null;
-function buildSessionDataFromAuthSession(session) {
-    const user = session?.user;
-    if (!user?.id && !user?.email) {
-        return null;
-    }
-    const expiresAt = session?.session?.expiresAt
-        ? new Date(session.session.expiresAt).getTime()
-        : Date.now() + 24 * 60 * 60 * 1000;
-    return {
-        userId: user.userId || user.id || '',
-        email: user.email || '',
-        name: user.name || undefined,
-        roles: Array.isArray(user.roles) ? user.roles : [],
-        idpAccessToken: user.idpAccessToken,
-        idpRefreshToken: user.idpRefreshToken,
-        idpAccessTokenExpires: user.idpAccessTokenExpires || expiresAt,
-        mfaVerified: user.mfaVerified ?? user.twoFactorSessionVerified ?? false,
-        oauthProvider: user.oauthProvider,
-        idpClientId: user.idpClientId,
-        merchantId: user.merchantId,
-    };
-}
-function attachSessionData(session, sessionData, sessionToken) {
-    if (!sessionData) {
-        return session;
-    }
-    const enrichedSessionData = {
-        ...sessionData,
-        ...(sessionToken ? { sessionToken } : {}),
-    };
-    session.sessionData = enrichedSessionData;
-    if (session?.user) {
-        const user = session.user;
-        user.userId = enrichedSessionData.userId || user.userId;
-        user.email = enrichedSessionData.email || user.email;
-        user.name = enrichedSessionData.name || user.name;
-        user.roles = enrichedSessionData.roles || user.roles || [];
-        user.idpAccessToken = enrichedSessionData.idpAccessToken;
-        user.idpRefreshToken = enrichedSessionData.idpRefreshToken;
-        user.idpAccessTokenExpires = enrichedSessionData.idpAccessTokenExpires;
-        user.mfaVerified = enrichedSessionData.mfaVerified;
-        user.twoFactorSessionVerified =
-            enrichedSessionData.mfaVerified ?? user.twoFactorSessionVerified;
-        user.oauthProvider = enrichedSessionData.oauthProvider || user.oauthProvider;
-        user.idpClientId = enrichedSessionData.idpClientId || user.idpClientId;
-        user.merchantId = enrichedSessionData.merchantId || user.merchantId;
-    }
-    return session;
-}
 /**
  * Get the initialized Better Auth instance (singleton).
  */
@@ -94,66 +75,31 @@ async function getSession(request) {
         const session = await auth.api.getSession({ headers: request.headers });
         if (!session?.session?.token || !session?.user)
             return session;
-        const sessionToken = session.session.token;
-        let sessionData = null;
-        // Prefer the app's normalized Redis session. Fall back to Better Auth's
-        // secondary storage record, then finally to whatever Better Auth already
-        // put on the request session object.
+        // Enrich with IDP tokens from Redis (stored by post-login hook)
         try {
-            sessionData = await (0, session_store_1.getSession)(sessionToken);
-            if (!sessionData) {
-                sessionData = await (0, session_store_1.getBetterAuthSession)(sessionToken);
+            const { getRedis } = await Promise.resolve().then(() => __importStar(require('../lib/redis')));
+            const { getAppSlug } = await Promise.resolve().then(() => __importStar(require('../lib/app-slug')));
+            const baKey = `ba:${getAppSlug()}:${session.session.token}`;
+            const baRaw = await getRedis().get(baKey);
+            if (baRaw) {
+                const baData = JSON.parse(baRaw);
+                if (baData.idpTokens) {
+                    const u = session.user;
+                    u.roles = baData.idpTokens.roles || [];
+                    u.userId = baData.idpTokens.userId;
+                    u.idpAccessToken = baData.idpTokens.idpAccessToken;
+                    u.idpRefreshToken = baData.idpTokens.idpRefreshToken;
+                    u.idpAccessTokenExpires = baData.idpTokens.idpAccessTokenExpires;
+                }
             }
         }
         catch { /* Redis unavailable */ }
-        if (!sessionData) {
-            sessionData = buildSessionDataFromAuthSession(session);
-        }
-        return attachSessionData(session, sessionData, sessionToken);
+        return session;
     }
     catch {
         return null;
     }
 }
-/**
- * Get normalized session data for the current request.
- *
- * This prefers the app's Redis session because it carries the canonical
- * IDP token, roles, and tenant-specific user identity used by app routes.
- */
-async function getSessionData(request) {
-    const session = await getSession(request);
-    const sessionData = session?.sessionData ||
-        buildSessionDataFromAuthSession(session);
-    if (!sessionData) {
-        return null;
-    }
-    const sessionToken = session?.session?.token;
-    return sessionToken
-        ? { ...sessionData, sessionToken }
-        : sessionData;
-}
-/**
- * Get the current request's IDP access token without triggering a refresh.
- *
- * Use this for routes that only need the currently-issued bearer token and
- * should fail closed instead of performing token lifecycle work.
- */
-async function getIdpToken(request) {
-    const sessionData = await getSessionData(request);
-    if (!sessionData) {
-        return { success: false, error: 'NO_SESSION', terminal: true };
-    }
-    const accessToken = sessionData.idpAccessToken || sessionData.accessToken;
-    if (!accessToken) {
-        return { success: false, error: 'NO_TOKEN', terminal: true };
-    }
-    return {
-        success: true,
-        accessToken,
-        sessionData,
-    };
-}
 /**
  * Get the current session, throwing if not authenticated.
  * Use in API handlers that require auth.

package/dist/vibe/hooks/index.d.ts

@@ -141,7 +141,7 @@ export declare function useVibeMutation<T extends VibeTableName, Op extends Muta
 /**
  * Convenience hook for creating records.
  */
-export declare function useVibeCreate<T extends VibeTableName>(table: T, options?: Omit<UseVibeMutationOptions<T, 'create'>, never>): import("@tanstack/react-query").UseMutationResult<VibeTableType<T>, VibeError, Omit<VibeTableType<T>, "created_at" | "id" | "updated_at">, unknown>;
+export declare function useVibeCreate<T extends VibeTableName>(table: T, options?: Omit<UseVibeMutationOptions<T, 'create'>, never>): import("@tanstack/react-query").UseMutationResult<VibeTableType<T>, VibeError, Omit<VibeTableType<T>, "id" | "created_at" | "updated_at">, unknown>;
 /**
  * Convenience hook for updating records.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payez/next-mvp",
-  "version": "4.0.49",
+  "version": "4.1.1",
   "sideEffects": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",