@driveflux/auth 4.0.90 → 4.0.91

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driveflux/auth",
-  "version": "4.0.90",
+  "version": "4.0.91",
   "type": "module",
   "exports": {
     ".": {
@@ -75,7 +75,7 @@
     "@casl/ability": "^6.8.1",
     "@casl/prisma": "^1.6.2",
     "@driveflux/config": "3.0.12",
-    "@driveflux/db": "4.1.20",
+    "@driveflux/db": "4.1.21",
     "@driveflux/fetch": "8.0.3",
     "@driveflux/problem": "6.0.3",
     "@driveflux/reporter": "7.0.4",