@driveflux/auth 4.0.86 → 4.0.88

package/dist/server/prisma-adapter.js

@@ -4,136 +4,172 @@ export function PrismaAdapter() {
     return {
         // TODO
         // @ts-expect-error TypeScript is not working here
-        createUser: async ({ id, groups, permissions, emailVerified, ...data }) => {
+        createUser: async ({ id, groups, permissions, emailVerified, ...data })=>{
             // @ts-expect-error
             const userData = {
                 id: id || generateId('User'),
-                groups: groups || ['member'],
+                groups: groups || [
+                    'member'
+                ],
                 permissions: permissions || {},
                 emailVerified: Boolean(emailVerified),
                 email: data.email.toLowerCase().trim(),
-                ...data,
+                ...data
             };
             const user = await prisma.user.create({
                 data: {
-                    ...userData,
-                },
+                    ...userData
+                }
             });
             return user;
         },
         // TODO
         // @ts-expect-error
-        getUser: (id) => prisma.user.findUnique({ where: { id } }),
+        getUser: (id)=>prisma.user.findUnique({
+                where: {
+                    id
+                }
+            }),
         // TODO
         // @ts-expect-error
-        getUserByEmail: (email) => prisma.user.findUnique({ where: { email: email.toLowerCase().trim() } }),
+        getUserByEmail: (email)=>prisma.user.findUnique({
+                where: {
+                    email: email.toLowerCase().trim()
+                }
+            }),
         // TODO
         // @ts-expect-error
-        async getUserByAccount(provider_providerAccountId) {
+        async getUserByAccount (provider_providerAccountId) {
             const account = await prisma.account.findUnique({
-                where: { provider_providerAccountId },
-                select: { user: true },
+                where: {
+                    provider_providerAccountId
+                },
+                select: {
+                    user: true
+                }
             });
             return account?.user ?? null;
         },
         // TODO
         // @ts-expect-error
-        updateUser: ({ id, ...data }) => {
+        updateUser: ({ id, ...data })=>{
             // @ts-expect-error
             const userData = {
                 email: data.email?.toLowerCase().trim(),
-                ...data,
+                ...data
             };
-            return prisma.user.update({ where: { id }, data: { ...userData } });
+            return prisma.user.update({
+                where: {
+                    id
+                },
+                data: {
+                    ...userData
+                }
+            });
         },
         // TODO
         // @ts-expect-error
-        deleteUser: (id) => prisma.user.delete({ where: { id } }),
+        deleteUser: (id)=>prisma.user.delete({
+                where: {
+                    id
+                }
+            }),
         // @ts-expect-error
-        linkAccount: ({ id, ...data }) => {
+        linkAccount: ({ id, ...data })=>{
             return prisma.account.create({
                 // @ts-expect-error
                 data: {
                     id: id || generateId('Account'),
-                    ...data,
-                },
+                    ...data
+                }
             });
         },
         // @ts-expect-error
-        unlinkAccount: (provider_providerAccountId) => prisma.account.delete({
-            where: { provider_providerAccountId },
-        }),
+        unlinkAccount: (provider_providerAccountId)=>prisma.account.delete({
+                where: {
+                    provider_providerAccountId
+                }
+            }),
         // TODO
         // @ts-expect-error
-        async getSessionAndUser(sessionToken) {
+        async getSessionAndUser (sessionToken) {
             const userAndSession = await prisma.session.findUnique({
-                where: { sessionToken },
-                include: { user: true },
+                where: {
+                    sessionToken
+                },
+                include: {
+                    user: true
+                }
             });
-            if (!userAndSession)
-                return null;
+            if (!userAndSession) return null;
             const { user, ...session } = userAndSession;
-            return { user, session };
+            return {
+                user,
+                session
+            };
         },
         // TODO
         // @ts-expect-error
-        async createSession({ id, ...data }) {
+        async createSession ({ id, ...data }) {
             const session = await prisma.session.create({
                 data: {
                     id: id || generateId('Session'),
-                    ...data,
-                },
+                    ...data
+                }
             });
             return session;
         },
-        updateSession: (data) => {
+        updateSession: (data)=>{
             return prisma.session.update({
-                where: { sessionToken: data.sessionToken },
-                data,
+                where: {
+                    sessionToken: data.sessionToken
+                },
+                data
             });
         },
-        deleteSession: async (sessionToken) => {
+        deleteSession: async (sessionToken)=>{
             try {
-                await prisma.session.delete({ where: { sessionToken } });
-            }
-            catch (_e) {
-                // TODO
-                // DO nothing for now
+                await prisma.session.delete({
+                    where: {
+                        sessionToken
+                    }
+                });
+            } catch (_e) {
+            // TODO
+            // DO nothing for now
             }
         },
         // TODO
         // @ts-expect-error
-        async createVerificationToken({ id, ...data }) {
+        async createVerificationToken ({ id, ...data }) {
             const verificationToken = await prisma.verificationToken.create({
                 data: {
                     id: id || generateId('VerificationToken'),
-                    ...data,
-                },
+                    ...data
+                }
             });
             // TODO
             // @ts-expect-errors // MongoDB needs an ID, but we don't
-            if (verificationToken.id)
-                verificationToken.id = undefined;
+            if (verificationToken.id) verificationToken.id = undefined;
             return verificationToken;
         },
-        async useVerificationToken(identifier_token) {
+        async useVerificationToken (identifier_token) {
             try {
                 const verificationToken = await prisma.verificationToken.delete({
-                    where: { identifier_token },
+                    where: {
+                        identifier_token
+                    }
                 });
                 // TODO
                 // @ts-expect-errors // MongoDB needs an ID, but we don't
-                if (verificationToken.id)
-                    verificationToken.id = undefined;
+                if (verificationToken.id) verificationToken.id = undefined;
                 return verificationToken;
-            }
-            catch (error) {
+            } catch (error) {
                 // If token already used/deleted, just return null
                 // https://www.prisma.io/docs/reference/api-reference/error-reference#p2025
-                if (error.code === 'P2025')
-                    return null;
+                if (error.code === 'P2025') return null;
                 throw error;
             }
-        },
+        }
     };
 }

package/dist/server/types.d.ts

@@ -18,4 +18,3 @@ declare module 'next-auth' {
     }
 }
 export {};
-//# sourceMappingURL=types.d.ts.map

package/dist/server/verfiy-token.d.ts

@@ -11,4 +11,3 @@ export declare const verifyToken: (tokenIdOrValue: string | TokenWithMaybeUser,
 export declare const clearToken: (tokenId: string) => Promise<void>;
 export declare const clearExpiredTokens: () => Promise<void>;
 export {};
-//# sourceMappingURL=verfiy-token.d.ts.map

package/dist/server/verfiy-token.js

@@ -1,29 +1,36 @@
 import { prisma } from '@driveflux/db';
-import { makeProblem, PROBLEM_CORRUPT, PROBLEM_EXPIRED, PROBLEM_INVALID_DATA, } from '@driveflux/problem';
+import { makeProblem, PROBLEM_CORRUPT, PROBLEM_EXPIRED, PROBLEM_INVALID_DATA } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
-export const verifyToken = async (tokenIdOrValue, verifications, option) => {
-    const token = typeof tokenIdOrValue === 'object'
-        ? tokenIdOrValue
-        : (await prisma.token.findFirst({
-            where: {
-                OR: [{ id: tokenIdOrValue }, { value: tokenIdOrValue }],
-            },
-            ...(option?.includeUser ? { include: { user: true } } : {}),
-        }));
+export const verifyToken = async (tokenIdOrValue, verifications, option)=>{
+    const token = typeof tokenIdOrValue === 'object' ? tokenIdOrValue : await prisma.token.findFirst({
+        where: {
+            OR: [
+                {
+                    id: tokenIdOrValue
+                },
+                {
+                    value: tokenIdOrValue
+                }
+            ]
+        },
+        ...option?.includeUser ? {
+            include: {
+                user: true
+            }
+        } : {}
+    });
     if (!token) {
         return new Err(makeProblem(PROBLEM_INVALID_DATA, 'Invalid token'));
     }
     if (token.expiresAt && token.expiresAt.getTime() < Date.now()) {
         return new Err(makeProblem(PROBLEM_EXPIRED, 'This token has expired'));
     }
-    if (typeof verifications?.scope !== 'undefined' &&
-        token.scope !== verifications.scope) {
+    if (typeof verifications?.scope !== 'undefined' && token.scope !== verifications.scope) {
         return new Err(makeProblem(PROBLEM_INVALID_DATA, 'Invalid token scope'));
     }
     if (typeof verifications?.metadata !== 'undefined') {
-        for (const key of Object.keys(verifications.metadata)) {
-            if (typeof verifications.metadata[key] !== 'undefined' &&
-                verifications.metadata[key] !== token.metadata?.[key]) {
+        for (const key of Object.keys(verifications.metadata)){
+            if (typeof verifications.metadata[key] !== 'undefined' && verifications.metadata[key] !== token.metadata?.[key]) {
                 return new Err(makeProblem(PROBLEM_INVALID_DATA, 'Invalid token data'));
             }
         }
@@ -33,22 +40,30 @@ export const verifyToken = async (tokenIdOrValue, verifications, option) => {
     }
     return new Ok(token);
 };
-export const clearToken = async (tokenId) => {
+export const clearToken = async (tokenId)=>{
     try {
         await prisma.token.delete({
             where: {
-                id: tokenId,
-            },
+                id: tokenId
+            }
         });
-    }
-    catch (_e) {
-        // Nothing to for now
+    } catch (_e) {
+    // Nothing to for now
     }
 };
-export const clearExpiredTokens = async () => {
+export const clearExpiredTokens = async ()=>{
     await prisma.token.deleteMany({
         where: {
-            OR: [{ expiresAt: { lte: new Date() } }, { invalid: true }],
-        },
+            OR: [
+                {
+                    expiresAt: {
+                        lte: new Date()
+                    }
+                },
+                {
+                    invalid: true
+                }
+            ]
+        }
     });
 };

package/dist/translations.d.ts

@@ -9,4 +9,3 @@ export declare const translations: {
 export declare const setTranslations: (ts: Partial<Translations>) => void;
 export declare const setTranslation: <K extends keyof Translations>(key: K, value: Translations[K]) => void;
 export {};
-//# sourceMappingURL=translations.d.ts.map

package/dist/translations.js

@@ -4,15 +4,15 @@ export const translations = singleton('authTranslations', {
     password: 'Password',
     unauthenticated: 'Unauthenticated',
     unauthenticatedDescription: 'You are not authenticated. Please log in to continue.',
-    wrongUsernameOrPassword: 'The username / password combination is invalid.',
+    wrongUsernameOrPassword: 'The username / password combination is invalid.'
 });
-export const setTranslations = (ts) => {
-    for (const key in ts) {
+export const setTranslations = (ts)=>{
+    for(const key in ts){
         // TODO
         // @ts-expect-error
         translations[key] = ts[key];
     }
 };
-export const setTranslation = (key, value) => {
+export const setTranslation = (key, value)=>{
     translations[key] = value;
 };

package/dist/types.d.ts

@@ -1,3 +1,2 @@
 export type * from 'next-auth';
 import './server/types.js';
-//# sourceMappingURL=types.d.ts.map

package/dist/use-auth.d.ts

@@ -1,2 +1 @@
 export declare const useAuth: () => import("./context.js").AuthContextObject;
-//# sourceMappingURL=use-auth.d.ts.map

package/dist/use-auth.js

@@ -1,5 +1,5 @@
 import { useContext } from 'react';
 import { AuthContext } from './context.js';
-export const useAuth = () => {
+export const useAuth = ()=>{
     return useContext(AuthContext);
 };

package/dist/use-session.d.ts

@@ -21,4 +21,3 @@ type SessionContextValue<R extends boolean = false> = R extends true ? {
 };
 export declare const useSession: <R extends boolean>(options?: UseSessionOptions<R>) => SessionContextValue<R>;
 export {};
-//# sourceMappingURL=use-session.d.ts.map

package/dist/use-session.js

@@ -1,4 +1,4 @@
 import { useSession as originalUseSession } from 'next-auth/react';
-export const useSession = (options) => {
+export const useSession = (options)=>{
     return originalUseSession(options);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driveflux/auth",
-  "version": "4.0.86",
+  "version": "4.0.88",
   "type": "module",
   "exports": {
     ".": {
@@ -72,41 +72,41 @@
     "dist"
   ],
   "dependencies": {
-    "@casl/ability": "^6.7.3",
-    "@casl/prisma": "^1.5.2",
-    "@driveflux/config": "3.0.10",
-    "@driveflux/db": "4.1.18",
-    "@driveflux/fetch": "8.0.1",
-    "@driveflux/problem": "6.0.1",
-    "@driveflux/reporter": "7.0.2",
-    "@driveflux/result": "6.0.1",
-    "@driveflux/singleton": "3.0.0",
-    "@driveflux/ui": "3.0.3",
-    "@driveflux/utils": "6.0.0",
-    "@driveflux/web-analytics": "3.0.3",
+    "@casl/ability": "^6.8.1",
+    "@casl/prisma": "^1.6.2",
+    "@driveflux/config": "3.0.11",
+    "@driveflux/db": "4.1.19",
+    "@driveflux/fetch": "8.0.2",
+    "@driveflux/problem": "6.0.2",
+    "@driveflux/reporter": "7.0.3",
+    "@driveflux/result": "6.0.2",
+    "@driveflux/singleton": "3.0.1",
+    "@driveflux/ui": "3.0.4",
+    "@driveflux/utils": "6.0.1",
+    "@driveflux/web-analytics": "3.0.4",
     "@types/cors": "^2.8.19",
-    "bcryptjs": "^3.0.2",
+    "bcryptjs": "^3.0.3",
     "change-case": "^5.4.4",
-    "cors": "^2.8.5",
-    "jose": "^6.1.0",
+    "cors": "^2.8.6",
+    "jose": "^6.2.3",
     "js-cookie": "^3.0.5",
-    "nanoid": "^5.1.6",
-    "next-auth": "^4.24.11",
-    "universal-cookie": "^8.0.1"
+    "nanoid": "^5.1.11",
+    "next-auth": "4.24.14",
+    "universal-cookie": "^8.1.2"
   },
   "devDependencies": {
-    "@driveflux/fab": "4.0.0",
-    "@driveflux/tsconfig": "3.0.0",
-    "@swc/cli": "^0.7.8",
-    "@swc/core": "^1.13.5",
+    "@driveflux/fab": "4.0.1",
+    "@driveflux/tsconfig": "3.0.1",
+    "@swc/cli": "^0.8.1",
+    "@swc/core": "^1.15.33",
     "@types/js-cookie": "^3.0.6",
-    "@types/node": "^24.9.1",
-    "@types/react": "19.2.2",
+    "@types/node": "^25.7.0",
+    "@types/react": "19.2.14",
     "del-cli": "^7.0.0",
-    "next": "16.0.7",
-    "react": "19.2.1",
-    "swr": "^2.3.6",
-    "typescript": "^5.9.3"
+    "next": "16.2.6",
+    "react": "19.2.6",
+    "swr": "^2.4.1",
+    "typescript": "^6.0.3"
   },
   "scripts": {
     "build": "fab",