nextjs-cms 0.5.55 → 0.5.56

package/dist/api/index.d.ts

@@ -63,6 +63,14 @@ declare const createCaller: import("@trpc/server").TRPCRouterCaller<{
                 password: string;
             };
             output: {
+                status: number;
+                session: {
+                    user: {
+                        id: string;
+                        name: string;
+                        locale: string | null;
+                    };
+                };
                 user: {
                     id: string;
                     username: string;

package/dist/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACrC,OAAO,EAAuB,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAElE;;;;;;GAMG;AACH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiC,CAAA;AAEnD;;;;;IAKI;AACJ,KAAK,YAAY,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAA;AAEhD;;;;;IAKI;AACJ,KAAK,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAA;AAElD,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,CAAA;AACrD,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AACrC,OAAO,EAAuB,iBAAiB,EAAE,MAAM,WAAW,CAAA;AAElE;;;;;;GAMG;AACH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAiC,CAAA;AAEnD;;;;;IAKI;AACJ,KAAK,YAAY,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAA;AAEhD;;;;;IAKI;AACJ,KAAK,aAAa,GAAG,kBAAkB,CAAC,SAAS,CAAC,CAAA;AAElD,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,YAAY,EAAE,CAAA;AACrD,YAAY,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,CAAA;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA"}

package/dist/api/root.d.ts

@@ -52,6 +52,14 @@ export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
                 password: string;
             };
             output: {
+                status: number;
+                session: {
+                    user: {
+                        id: string;
+                        name: string;
+                        locale: string | null;
+                    };
+                };
                 user: {
                     id: string;
                     username: string;

package/dist/api/root.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../src/api/root.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgBpB,CAAA;AAIF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA"}
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../src/api/root.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgBpB,CAAA;AAIF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA"}

package/dist/api/routers/auth.d.ts

@@ -29,6 +29,14 @@ export declare const authRouter: import("@trpc/server").TRPCBuiltRouter<{
             password: string;
         };
         output: {
+            status: number;
+            session: {
+                user: {
+                    id: string;
+                    name: string;
+                    locale: string | null;
+                };
+            };
             user: {
                 id: string;
                 username: string;

package/dist/api/routers/auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/api/routers/auth.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBrB,CAAA"}
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/api/routers/auth.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBrB,CAAA"}

package/dist/auth/hooks/useRefreshToken.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRefreshToken.d.ts","sourceRoot":"","sources":["../../../src/auth/hooks/useRefreshToken.tsx"],"names":[],"mappings":"AAEA;;;GAGG;AACH,QAAA,MAAM,eAAe,8BA6EpB,CAAA;AAED,eAAe,eAAe,CAAA"}
+{"version":3,"file":"useRefreshToken.d.ts","sourceRoot":"","sources":["../../../src/auth/hooks/useRefreshToken.tsx"],"names":[],"mappings":"AAGA;;;GAGG;AACH,QAAA,MAAM,eAAe,8BA8EpB,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/auth/hooks/useRefreshToken.js

@@ -1,13 +1,15 @@
+import * as React from 'react';
 import { logout, refreshSession } from '../react.js';
 /**
  * This hook is used to refresh the access token when it expires.
  * It is used in the useAxiosPrivate hook to refresh the access token when a request returns a 401 error.
  */
 const useRefreshToken = () => {
-    let isRefreshing = false; // Is a refresh request being sent?
-    let failedQueue = []; // An array of requests that failed because of 401
+    const isRefreshingRef = React.useRef(false); // Is a refresh request being sent?
+    // An array of requests that failed because of 401
+    const failedQueueRef = React.useRef([]);
     const processQueue = (error, token = null) => {
-        failedQueue.forEach((prom) => {
+        failedQueueRef.current.forEach((prom) => {
             if (error) {
                 prom.reject(error);
             }
@@ -15,7 +17,7 @@ const useRefreshToken = () => {
                 prom.resolve(token);
             }
         });
-        failedQueue = [];
+        failedQueueRef.current = [];
     };
     const refresh = async () => {
         try {
@@ -24,7 +26,7 @@ const useRefreshToken = () => {
             /**
              * The refresh request is done
              */
-            isRefreshing = false;
+            isRefreshingRef.current = false;
             if (response.status !== 200) {
                 /**
                  * If the refresh token is invalid, we log out the user
@@ -41,7 +43,7 @@ const useRefreshToken = () => {
                 /**
                  * update the session
                  */
-                await refreshSession();
+                await refreshSession(data.session);
             }
             /**
              * Process the failed requests
@@ -65,14 +67,14 @@ const useRefreshToken = () => {
     // TODO: Apply this inside useAxiosPrivate.tsx to prevent even the 401 errors from happening
     // Let's use semaphores to prevent multiple refreshes at the same time
     return async () => {
-        if (isRefreshing) {
+        if (isRefreshingRef.current) {
             // If a refresh request is being sent, we return a promise
             // that will be resolved when the refresh request is done
             return new Promise((resolve, reject) => {
-                failedQueue.push({ resolve, reject });
+                failedQueueRef.current.push({ resolve, reject });
             });
         }
-        isRefreshing = true; // A refresh request is being sent
+        isRefreshingRef.current = true; // A refresh request is being sent
         return await refresh(); // Send the refresh request and return the new access token
     };
 };

package/dist/auth/lib/actions.d.ts

@@ -5,10 +5,12 @@ export declare const authRefresh: (refreshToken?: {
     status: number;
     code: string;
     state: string;
+    session?: undefined;
     user?: undefined;
 } | {
     status: number;
     state: string;
+    session: Session;
     user: {
         id: string;
         username: string;
@@ -21,6 +23,14 @@ export declare const login: ({ username, password }: {
     username: string;
     password: string;
 }) => Promise<{
+    status: number;
+    session: {
+        user: {
+            id: string;
+            name: string;
+            locale: string | null;
+        };
+    };
     user: {
         id: string;
         username: string;

package/dist/auth/lib/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/auth/lib/actions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,eAAO,MAAM,WAAW,GAAU,eAAe;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;EA4GjE,CAAA;AAED,eAAO,MAAM,KAAK,GAAU,wBAAwB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE;;;;;;;;EA+FzF,CAAA;AAED,eAAO,MAAM,aAAa,GAAU,UAAU,OAAO,GAAG,IAAI,qBA0B3D,CAAA"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/auth/lib/actions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,eAAO,MAAM,WAAW,GAAU,eAAe;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;EA4HjE,CAAA;AAED,eAAO,MAAM,KAAK,GAAU,wBAAwB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;EA+GzF,CAAA;AAED,eAAO,MAAM,aAAa,GAAU,UAAU,OAAO,GAAG,IAAI,qBA0B3D,CAAA"}

package/dist/auth/lib/actions.js

@@ -29,7 +29,7 @@ export const authRefresh = async (refreshToken) => {
             .where(and(eq(AccessTokensTable.adminId, decoded.id), eq(AccessTokensTable.refreshToken, refreshToken.value)))
             .limit(1);
         const adminTokenResult = result[0];
-        if (!adminTokenResult) {
+        if (!adminTokenResult || !adminTokenResult.adminId || !adminTokenResult.username) {
             return {
                 status: 401,
                 code: 'invalid_refresh_token',
@@ -39,17 +39,24 @@ export const authRefresh = async (refreshToken) => {
         // Let's create a JWT access token and refresh token
         const accessToken = encodeJWT({
             id: decoded.id,
-            iss: 'Lazemni CMS',
+            iss: 'nextjs-cms',
             aud: 'admin',
             sub: adminTokenResult.username,
             locale: adminTokenResult.locale || 'en',
         });
         const newRefreshToken = encodeRefreshToken({
             id: adminTokenResult.adminId,
-            iss: 'Lazemni CMS',
+            iss: 'nextjs-cms',
             aud: 'admin',
             sub: adminTokenResult.username,
         });
+        if (!accessToken || !newRefreshToken) {
+            return {
+                status: 401,
+                code: 'failed_to_create_tokens',
+                state: 'logged_out',
+            };
+        }
         // Let's update the refresh token in the database
         await db
             .update(AccessTokensTable)
@@ -78,10 +85,17 @@ export const authRefresh = async (refreshToken) => {
             sameSite: true,
             maxAge: 60 * 60 * 2, // 2 hours
         });
+        const session = {
+            user: {
+                id: adminTokenResult.adminId,
+                name: adminTokenResult.username,
+                locale: adminTokenResult.locale ?? null,
+            },
+        };
         return {
             status: 200,
-            // accessToken: accessToken,
             state: 'logged_in',
+            session,
             user: {
                 id: adminTokenResult.adminId,
                 username: adminTokenResult.username,
@@ -114,7 +128,7 @@ export const login = async ({ username, password }) => {
         .where(eq(AdminsTable.user, username))
         .limit(1);
     const admin = result[0];
-    if (!admin) {
+    if (!admin || !admin.password || !admin.id || !admin.username) {
         throw new Error('Invalid credentials');
     }
     // Verify password with bcrypt
@@ -125,33 +139,41 @@ export const login = async ({ username, password }) => {
     // Let's create a JWT access token and refresh token
     const accessToken = encodeJWT({
         id: admin.id,
-        iss: 'Lazemni CMS',
+        iss: 'nextjs-cms',
         aud: 'admin',
         sub: admin.username,
         locale: admin.locale || 'en',
     });
     const refreshToken = encodeRefreshToken({
         id: admin.id,
-        iss: 'Lazemni CMS',
+        iss: 'nextjs-cms',
         aud: 'admin',
         sub: admin.username,
     });
-    // Let's save the refresh token in the database
-    await db
-        .insert(AccessTokensTable)
-        .values({
-        accessToken,
-        refreshToken,
-        adminId: admin.id,
-        expiration: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
-    })
-        .onDuplicateKeyUpdate({
-        set: {
+    if (!accessToken || !refreshToken) {
+        throw new Error('Failed to create access and refresh tokens');
+    }
+    try {
+        // Let's save the refresh token in the database
+        await db
+            .insert(AccessTokensTable)
+            .values({
             accessToken,
             refreshToken,
+            adminId: admin.id,
             expiration: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
-        },
-    });
+        })
+            .onDuplicateKeyUpdate({
+            set: {
+                accessToken,
+                refreshToken,
+                expiration: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+            },
+        });
+    }
+    catch (error) {
+        throw new Error('Failed to save access and refresh tokens to database');
+    }
     const cookieStore = await cookies();
     // Let's send the refresh token as a cookie
     cookieStore.set({
@@ -173,6 +195,14 @@ export const login = async ({ username, password }) => {
     });
     // Now, return the access token in body
     return {
+        status: 200,
+        session: {
+            user: {
+                id: admin.id,
+                name: admin.username,
+                locale: admin.locale,
+            },
+        },
         user: {
             id: admin.id,
             username: admin.username,

package/dist/auth/react.d.ts

@@ -45,6 +45,12 @@ export interface AuthClientConfig {
      * trigger session updates from places like `signIn` or `signOut`
      */
     _getSession: (...args: any[]) => any;
+    /**
+     * Directly set the session in the current tab/window,
+     * after being fetched from the server during a refresh request.
+     * This is to avoid the need to fetch the session from the server again.
+     */
+    _setSession: (session: Session | null) => void;
 }
 export declare const __AUTH: AuthClientConfig;
 export declare function logout(options?: {
@@ -54,7 +60,7 @@ export declare function login({ username, password }: {
     username: string;
     password: string;
 }): Promise<void>;
-export declare function refreshSession(): Promise<void>;
+export declare function refreshSession(session: Session): Promise<void>;
 /**
  * Returns the current CSRF token.
  * required to make requests that changes state.

package/dist/auth/react.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/auth/react.tsx"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAEzC,OAAO,eAAe,MAAM,4BAA4B,CAAA;AACxD,OAAO,eAAe,MAAM,4BAA4B,CAAA;AAGxD,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAAA;AACnE,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAAA;IACxB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB;;;OAGG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,KAAK,CAAA;CAC7B;AAED,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,OAAO;IAChD,QAAQ,EAAE,CAAC,CAAA;IACX,2BAA2B;IAC3B,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAA;CACjC;AAED,MAAM,WAAW,gBAAgB;IAC7B,KAAK,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;IAC/C,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,SAAS,CAAC,EAAE,OAAO,CAAA;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC7B,QAAQ,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,CAAA;IACrC,wDAAwD;IACxD,SAAS,EAAE,MAAM,CAAA;IACjB;;;OAGG;IACH,WAAW,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAA;CACvC;AAED,eAAO,MAAM,MAAM,EAAE,gBAIpB,CAAA;AAED,wBAAsB,MAAM,CAAC,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE,iBA2BjE;AAED,wBAAsB,KAAK,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,iBAyBzF;AAED,wBAAsB,cAAc,kBAWnC;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,oBAGjC;AAwBD,wBAAsB,UAAU,CAAC,MAAM,CAAC,EAAE,gBAAgB,2BAWzD;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,OAAO,GAAG,KAAK,IAAI,CAAC,SAAS,IAAI,GAE/D;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GACjE;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,GAExD;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GACjE;IACI,MAAM,EAAE,aAAa,CAAA;IACrB,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAA;CACxC,CAAA;AAEb,eAAO,MAAM,cAAc;YAPL,aAAa;UAAQ,OAAO;YAAU,eAAe;;YAEnD,aAAa;UACf,IAAI;YACF,iBAAiB,GAAG,SAAS;cAG0C,CAAA;AAE/F,wBAAgB,UAAU,CAAC,CAAC,SAAS,OAAO,EAAE,OAAO,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CA6BpG;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,qBAiN1D;AAED,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,CAAA;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAA"}
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/auth/react.tsx"],"names":[],"mappings":"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"}

package/dist/auth/react.js

@@ -11,6 +11,7 @@ export const __AUTH = {
     _lastSync: 0,
     _session: undefined,
     _getSession: () => { },
+    _setSession: () => { },
 };
 export async function logout(options) {
     const { deleteCookies = true } = options ?? {};
@@ -51,26 +52,27 @@ export async function login({ username, password }) {
         const error = await response.json();
         throw new Error(error.error);
     }
+    const data = await response.json();
     /**
      * Broadcast a message to all other tabs/windows to tell them the user has logged in.
      * This is to ensure all tabs/windows trigger a session update.
      */
-    broadcast().postMessage({ event: 'session', data: { trigger: 'login' } });
+    broadcast().postMessage({ event: 'session', data: { trigger: 'refetch' } });
     /**
      * Update the session in the current tab/window.
      */
-    await __AUTH._getSession({ event: 'storage' });
+    __AUTH._setSession(data.session);
 }
-export async function refreshSession() {
+export async function refreshSession(session) {
     /**
      * Broadcast a message to all other tabs/windows to tell them the session has been updated.
      * This is to ensure all tabs/windows trigger a session update.
      */
-    broadcast().postMessage({ event: 'session', data: { trigger: 'refresh' } });
+    broadcast().postMessage({ event: 'session', data: { trigger: 'refetch' } });
     /**
      * Update the session in the current tab/window.
      */
-    await __AUTH._getSession({ event: 'storage' });
+    __AUTH._setSession(session);
 }
 /**
  * Returns the current CSRF token.
@@ -90,8 +92,8 @@ function broadcast() {
     if (typeof BroadcastChannel === 'undefined') {
         return {
             postMessage: () => { },
-            addEventListener: () => { },
-            removeEventListener: () => { },
+            addEventListener: (_type, _listener) => { },
+            removeEventListener: (_type, _listener) => { },
         };
     }
     if (broadcastChannel === null) {
@@ -176,6 +178,11 @@ export function SessionProvider(props) {
     /** If session was passed, initialize as not loading */
     const [loading, setLoading] = React.useState(!hasInitialSession);
     React.useEffect(() => {
+        __AUTH._setSession = (session) => {
+            __AUTH._lastSync = now();
+            __AUTH._session = session;
+            setSession(session);
+        };
         async function generateInitialSession() {
             /**
              * Use the `axiosPrivate` instance to make a request to `/api/auth/session` to get the
@@ -209,18 +216,15 @@ export function SessionProvider(props) {
          */
         init()
             .then(async (session) => {
-            if (session) {
+            /**
+             * Only update if we fetched a new session (i.e., no initial session was provided).
+             * When hasInitialSession is true, __AUTH._session and state are already set,
+             * so we skip the redundant update.
+             */
+            if (!hasInitialSession && session) {
                 __AUTH._session = session;
                 setSession(session);
             }
-            else {
-                /**
-                 * It's not necessary to log out the user and broadcast the logout event,
-                 * because there are no cookies set to delete.
-                 * But it's a good practice to do so.
-                 */
-                // await logout()
-            }
         })
             .then(() => {
             __AUTH._getSession = async ({ event } = {}) => {
@@ -235,11 +239,11 @@ export function SessionProvider(props) {
                         return;
                     }
                     /**
-                     * If the event is a storage event, we should update the session and not broadcast the event.
-                     * Storage events can also be triggered when a broadcast message is sent from another
+                     * If the event is a refetch event, we should update the session and not broadcast the event.
+                     * Refetch events can be triggered when a broadcast message is sent from another
                      * tab/window. (see below)
                      */
-                    if (event === 'storage') {
+                    if (event === 'refetch') {
                         __AUTH._lastSync = now();
                         __AUTH._session = await getSession({
                             broadcast: false,
@@ -254,7 +258,7 @@ export function SessionProvider(props) {
                     !event ||
                         // If the client doesn't have a session then we don't need to call
                         // the server to check if it does (if they have signed in via another
-                        // tab or window that will come through as a "storage" event anyway)
+                        // tab or window that will come through as a "refetch" event anyway)
                         __AUTH._session === null ||
                         // Bail out early if the client session is not stale yet
                         now() < __AUTH._lastSync) {
@@ -281,21 +285,39 @@ export function SessionProvider(props) {
             __AUTH._lastSync = 0;
             __AUTH._session = undefined;
             __AUTH._getSession = () => { };
+            __AUTH._setSession = () => { };
         };
     }, []);
     React.useEffect(() => {
-        const handle = () => __AUTH._getSession({ event: 'storage' });
-        // Listen for storage events and update session if event fired from
-        // another window (but suppress firing another event to avoid a loop)
-        // Fetch new session data but tell it not to fire another event to
-        // avoid an infinite loop.
+        const handleBroadcastMessage = (event) => {
+            try {
+                const message = event.data;
+                // Only handle session-related broadcast messages
+                if (message.event !== 'session')
+                    return;
+                // Handle logout events by updating the session directly
+                if (message.data?.trigger === 'logout') {
+                    __AUTH._getSession({ event: 'logout' });
+                }
+                // Handle refetch events by updating the session directly
+                if (message.data?.trigger === 'refetch') {
+                    __AUTH._getSession({ event: 'refetch' });
+                }
+            }
+            catch (error) {
+                // Ignore invalid JSON or malformed messages
+                console.warn('Failed to parse broadcast message:', error);
+            }
+        };
+        // Listen for broadcast events fired from another tab/window
+        // refetch/logout the current session data depending on the event
         // Note: We could pass session data through and do something like
         // `setData(message.data)` but that can cause problems depending
         // on how the session object is being used in the client; it is
         // more robust to have each window/tab fetch it's own copy of the
         // session object rather than share it across instances.
-        broadcast().addEventListener('message', handle);
-        return () => broadcast().removeEventListener('message', handle);
+        broadcast().addEventListener('message', handleBroadcastMessage);
+        return () => broadcast().removeEventListener('message', handleBroadcastMessage);
     }, []);
     React.useEffect(() => {
         const { refetchOnWindowFocus = true } = props;
@@ -335,7 +357,7 @@ export function SessionProvider(props) {
                 setSession(newSession);
                 broadcast().postMessage({
                     event: 'session',
-                    data: { trigger: 'getSession' },
+                    data: { trigger: 'refetch' },
                 });
             }
             return newSession;

package/dist/auth/trpc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../../src/auth/trpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAM5C;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAO,QAAQ,CAAC,aAAa,CAAC,GAAG,CA4E7D,CAAA"}
+{"version":3,"file":"trpc.d.ts","sourceRoot":"","sources":["../../src/auth/trpc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAM5C;;GAEG;AACH,eAAO,MAAM,gBAAgB,QAAO,QAAQ,CAAC,aAAa,CAAC,GAAG,CA6E7D,CAAA"}

package/dist/auth/trpc.js

@@ -25,6 +25,7 @@ export const refreshTokenLink = () => {
                                     refreshPromise = (async () => {
                                         try {
                                             const response = await fetch('/api/auth/refresh');
+                                            const data = await response.json();
                                             if (response.status !== 200) {
                                                 await logout({
                                                     /**
@@ -34,7 +35,7 @@ export const refreshTokenLink = () => {
                                                 });
                                                 return;
                                             }
-                                            await refreshSession();
+                                            await refreshSession(data.session);
                                         }
                                         catch (e) {
                                             await logout({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextjs-cms",
-  "version": "0.5.55",
+  "version": "0.5.56",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "type": "module",
@@ -142,8 +142,8 @@
     "tsx": "^4.20.6",
     "typescript": "^5.9.2",
     "@lzcms/eslint-config": "0.3.0",
-    "@lzcms/prettier-config": "0.1.0",
-    "@lzcms/tsconfig": "0.1.0"
+    "@lzcms/tsconfig": "0.1.0",
+    "@lzcms/prettier-config": "0.1.0"
   },
   "license": "MIT",
   "keywords": [