@driveflux/auth 4.0.90 → 4.0.91

package/dist/AuthProvider.js

@@ -6,37 +6,34 @@ import { useToastResult } from '@driveflux/ui/toast';
 import { useTrackEvent } from '@driveflux/web-analytics/track';
 import Cookies from 'js-cookie';
 import Router, { useRouter } from 'next/router';
-import { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import useSWR from 'swr';
 import { AuthContext } from './context.js';
 import { translations } from './translations.js';
-const AuthProvider = ({ children }) => {
+const AuthProvider = ({ children })=>{
     const { data: session, status, update } = useAuthSession();
     const { setUserData } = useTrackEvent();
     const [token, setToken] = useState(null);
     /**
-     * A reference to a promise that fetches a new access token from the server.
-     * This is used to prevent multiple token requests from being sent simultaneously.
-     */
-    const newTokenPromise = useRef(null);
+	 * A reference to a promise that fetches a new access token from the server.
+	 * This is used to prevent multiple token requests from being sent simultaneously.
+	 */ const newTokenPromise = useRef(null);
     const localeLogicRan = useRef(false);
     const router = useRouter();
     const { pathname, asPath, query, locale } = router;
     const { toastResult } = useToastResult();
-    const { data: user, isValidating, mutate, error, } = useSWR(session ? `${config.apiUrl}/user` : null, {
-        fallbackData: session
-            ?.user,
+    const { data: user, isValidating, mutate, error } = useSWR(session ? `${config.apiUrl}/user` : null, {
+        fallbackData: session?.user
     });
     const isLoadingUser = status !== 'unauthenticated' && isValidating && !user;
     /**
-     * Retrieves an access token for the current user. If a token is already available and has not expired, it will be returned immediately.
-     * Otherwise, the function will attempt to retrieve the token from cookies, and if that fails, it will fetch a new token from the server.
-     * If a new token is fetched, it will be stored in cookies and returned.
-     * If the user is not authenticated, the function will return null and display an error message.
-     * @returns {Promise<string | null>} A promise that resolves to the access token string, or null if the user is not authenticated.
-     */
-    // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>
-    const getAccessToken = useCallback(async () => {
+	 * Retrieves an access token for the current user. If a token is already available and has not expired, it will be returned immediately.
+	 * Otherwise, the function will attempt to retrieve the token from cookies, and if that fails, it will fetch a new token from the server.
+	 * If a new token is fetched, it will be stored in cookies and returned.
+	 * If the user is not authenticated, the function will return null and display an error message.
+	 * @returns {Promise<string | null>} A promise that resolves to the access token string, or null if the user is not authenticated.
+	 */ // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>
+    const getAccessToken = useCallback(async ()=>{
         // Check the state first, if we have a token, return it
         if (token && token.expiresAt > new Date()) {
             return token.accessToken;
@@ -49,19 +46,17 @@ const AuthProvider = ({ children }) => {
                 if (expiresAt > new Date()) {
                     setToken({
                         accessToken: tokenFromCookies.accessToken,
-                        expiresAt,
+                        expiresAt
                     });
                 }
                 return tokenFromCookies.accessToken;
             }
+        } catch (_e) {
+        // TODO
+        // Nothing to do here
         }
-        catch (_e) {
-            // TODO
-            // Nothing to do here
-        }
-        const tokenPromise = newTokenPromise.current ||
-            // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
-            (newTokenPromise.current = enhancedFetch(`${config.apiUrl}/user/token`));
+        const tokenPromise = newTokenPromise.current || // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
+        (newTokenPromise.current = enhancedFetch(`${config.apiUrl}/user/token`));
         // As a last resort, fetch a new token
         const newToken = await tokenPromise;
         // Resets the newTokenPromise reference to null after the new token has been fetched.
@@ -70,42 +65,50 @@ const AuthProvider = ({ children }) => {
             toastResult(newToken, {
                 error: {
                     title: translations.unauthenticated,
-                    description: translations.unauthenticatedDescription,
-                },
+                    description: translations.unauthenticatedDescription
+                }
             });
             return null;
         }
         const newTokenDetils = {
             accessToken: newToken.val.id,
-            expiresAt: new Date(newToken.val.expiresAt),
+            expiresAt: new Date(newToken.val.expiresAt)
         };
         Cookies.set('accessTokenDetails', JSON.stringify(newTokenDetils));
         setToken(newTokenDetils);
         return newToken.val.id;
-    }, [token]);
-    const refresh = useCallback(async () => {
+    }, [
+        token
+    ]);
+    const refresh = useCallback(async ()=>{
         await update();
         return await mutate();
-    }, [mutate, update]);
-    const logout = useCallback(async () => {
-        await signOut({ redirect: false });
+    }, [
+        mutate,
+        update
+    ]);
+    const logout = useCallback(async ()=>{
+        await signOut({
+            redirect: false
+        });
         await refresh();
-    }, [refresh]);
-    const context = useMemo(() => ({
-        user,
-        isLoadingUser,
-        refresh,
-        error,
-        getAccessToken,
-        // TODO
-        /**
-         * @deprecated do not use this property, use getAccessToken instead
-         */
-        accessToken: token?.accessToken,
-        signIn,
-        logout,
-        status,
-    }), [
+    }, [
+        refresh
+    ]);
+    const context = useMemo(()=>({
+            user,
+            isLoadingUser,
+            refresh,
+            error,
+            getAccessToken,
+            // TODO
+            /**
+			 * @deprecated do not use this property, use getAccessToken instead
+			 */ accessToken: token?.accessToken,
+            signIn,
+            logout,
+            status
+        }), [
         user,
         isLoadingUser,
         refresh,
@@ -113,11 +116,11 @@ const AuthProvider = ({ children }) => {
         getAccessToken,
         logout,
         token,
-        status,
+        status
     ]);
     // Add preferredLocal if any
     // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>
-    useEffect(() => {
+    useEffect(()=>{
         if (localeLogicRan.current || !user) {
             return;
         }
@@ -125,23 +128,37 @@ const AuthProvider = ({ children }) => {
         const langFromCookies = Cookies.get('NEXT_LOCALE');
         if (user?.preferredLocale && langFromCookies !== user?.preferredLocale) {
             Cookies.set('NEXT_LOCALE', user.preferredLocale);
-            Router.push({ pathname, query }, asPath, { locale: user.preferredLocale });
+            Router.push({
+                pathname,
+                query
+            }, asPath, {
+                locale: user.preferredLocale
+            });
         }
-    }, [user?.preferredLocale, pathname, query, asPath]);
+    }, [
+        user?.preferredLocale,
+        pathname,
+        query,
+        asPath
+    ]);
     // Add user to the tracking
     // biome-ignore lint/correctness/useExhaustiveDependencies: <explanation>
-    useEffect(() => {
-        if (!user)
-            return;
+    useEffect(()=>{
+        if (!user) return;
         setUserData({
             id: user.id,
             email: user.email,
             phoneNumber: user.phoneNumber,
             firstName: user.firstName,
             lastName: user.lastName,
-            addresses: user.addresses,
+            addresses: user.addresses
         });
-    }, [user]);
-    return _jsx(AuthContext.Provider, { value: context, children: children });
+    }, [
+        user
+    ]);
+    return /*#__PURE__*/ _jsx(AuthContext.Provider, {
+        value: context,
+        children: children
+    });
 };
 export default AuthProvider;

package/dist/authorization/define.js

@@ -1,6 +1,6 @@
 import { AbilityBuilder } from '@casl/ability';
 import { createPrismaAbility } from '@casl/prisma';
-import { ALL_ADMIN_ROLES, CONSUMER_ROLES, GENERAL_ROLES, HIGHER_ADMIN_ROLES, OWNER_ROLES, } from './constants.js';
+import { ALL_ADMIN_ROLES, CONSUMER_ROLES, GENERAL_ROLES, HIGHER_ADMIN_ROLES, OWNER_ROLES } from './constants.js';
 import { defineRoleAbilitiesBusinessDevelopmentExecutive } from './roles/admin/business-development-executive.js';
 import { defineRoleAbilitiesCeo } from './roles/admin/ceo.js';
 import { defineRoleAbilitiesCommonAdmin } from './roles/admin/common.js';
@@ -26,45 +26,64 @@ import { defineRoleAbilitiesSalesExecutive } from './roles/admin/sales-executive
 import { defineRoleAbilitiesBusinessAdmin } from './roles/consumer/business-admin.js';
 import { defineRoleAbilitiesBusinessUser } from './roles/consumer/business-user.js';
 import { defineRoleAbilitiesMember } from './roles/consumer/member.js';
-export const defineAbilityFor = async (user) => {
+export const defineAbilityFor = async (user)=>{
     const { can, cannot, build } = new AbilityBuilder(createPrismaAbility);
     if (!user) {
         return build();
     }
-    const groups = Array.isArray(user.groups)
-        ? user.groups.map((r) => `${r}`)
-        : typeof user.groups === 'string'
-            ? [user.groups]
-            : [];
-    const consumerGroups = groups.filter((g) => CONSUMER_ROLES.includes(g));
-    const adminGroups = groups.filter((g) => !consumerGroups.includes(g));
-    const sortedGroups = [...consumerGroups, ...adminGroups];
-    for (const role of sortedGroups) {
+    const groups = Array.isArray(user.groups) ? user.groups.map((r)=>`${r}`) : typeof user.groups === 'string' ? [
+        user.groups
+    ] : [];
+    const consumerGroups = groups.filter((g)=>CONSUMER_ROLES.includes(g));
+    const adminGroups = groups.filter((g)=>!consumerGroups.includes(g));
+    const sortedGroups = [
+        ...consumerGroups,
+        ...adminGroups
+    ];
+    for (const role of sortedGroups){
         await defineSpecificRoleAbilities(role, can, cannot, user);
     }
     // Common admin abilities
-    if (user.groups.some((g) => adminGroups.includes(g))) {
+    if (user.groups.some((g)=>adminGroups.includes(g))) {
         await defineRoleAbilitiesCommonAdmin(can);
     }
     // General abilities
-    can(['read', 'update'], 'User', { id: user.id });
-    can(['read'], 'Invoice', { payerId: user.id });
+    can([
+        'read',
+        'update'
+    ], 'User', {
+        id: user.id
+    });
+    can([
+        'read'
+    ], 'Invoice', {
+        payerId: user.id
+    });
     if (user.businessId) {
-        can(['read'], 'Invoice', { payerId: user.businessId });
+        can([
+            'read'
+        ], 'Invoice', {
+            payerId: user.businessId
+        });
     }
-    can('reserveVehicle', 'User', { banned: false, consented: true });
+    can('reserveVehicle', 'User', {
+        banned: false,
+        consented: true
+    });
     // Prevent updating the groups for all users
-    cannot('update', 'User', ['groups']);
+    cannot('update', 'User', [
+        'groups'
+    ]);
     return build();
 };
-const defineSpecificRoleAbilities = async (r, can, cannot, rawUser) => {
+const defineSpecificRoleAbilities = async (r, can, cannot, rawUser)=>{
     if (!~GENERAL_ROLES.indexOf(r)) {
         return;
     }
     // Type issue
     const user = rawUser;
     const role = r;
-    switch (role) {
+    switch(role){
         // Owners
         case 'ceo':
             defineRoleAbilitiesCeo(can);
@@ -142,20 +161,30 @@ const defineSpecificRoleAbilities = async (r, can, cannot, rawUser) => {
         case 'businessAdmin':
             defineRoleAbilitiesBusinessAdmin(can, user);
             break;
-        default: {
-            const _exhaustiveCheck = role;
-            break;
-        }
+        default:
+            {
+                const _exhaustiveCheck = role;
+                break;
+            }
     }
-    if (![...OWNER_ROLES, ...HIGHER_ADMIN_ROLES].includes(role)) {
+    if (![
+        ...OWNER_ROLES,
+        ...HIGHER_ADMIN_ROLES
+    ].includes(role)) {
         cannot('manageAdmin', 'User');
-        cannot(['create', 'update', 'delete'], 'User', undefined, {
+        cannot([
+            'create',
+            'update',
+            'delete'
+        ], 'User', undefined, {
             groups: {
-                hasSome: [...ALL_ADMIN_ROLES],
-            },
+                hasSome: [
+                    ...ALL_ADMIN_ROLES
+                ]
+            }
         }).because('You are not allowed to update admin users');
         can('update', 'User', undefined, {
-            id: user.id,
+            id: user.id
         });
     }
 };

package/dist/authorization/fields/index.js

@@ -1,6 +1,5 @@
 import { Prisma, prisma } from '@driveflux/db';
-export const MODEL_FIELDS = Object.keys(Prisma.ModelName)
-    .map((k) => {
+export const MODEL_FIELDS = Object.keys(Prisma.ModelName).map((k)=>{
     if (!(k in Prisma.ModelName)) {
         return null;
     }
@@ -8,17 +7,15 @@ export const MODEL_FIELDS = Object.keys(Prisma.ModelName)
     return {
         // TODO
         // @ts-expect-error
-        [key]: prisma._runtimeDataModel.models[key].fields.map((f) => f.name),
+        [key]: prisma._runtimeDataModel.models[key].fields.map((f)=>f.name)
     };
-})
-    .filter((m) => m)
-    .reduce((carry, current) => {
+}).filter((m)=>m).reduce((carry, current)=>{
     if (current) {
         Object.assign(carry, current);
     }
     return carry;
 }, {});
-export const getModelFields = (model) => {
+export const getModelFields = (model)=>{
     const fields = MODEL_FIELDS[model];
     return fields;
 };

package/dist/authorization/helpers.js

@@ -1,16 +1,18 @@
 import { ALL_ADMIN_ROLES, CONSUMER_ROLES, OWNER_ROLES } from './constants';
-export const extractAdminRoles = (userGroups) => {
-    return userGroups?.filter((group) => isAdmin(group));
+export const extractAdminRoles = (userGroups)=>{
+    return userGroups?.filter((group)=>isAdmin(group));
 };
-export const extractNonAdminRoles = (userGroups) => {
-    return userGroups?.filter((group) => !isAdmin(group));
+export const extractNonAdminRoles = (userGroups)=>{
+    return userGroups?.filter((group)=>!isAdmin(group));
 };
-export const isConsumer = (group) => {
+export const isConsumer = (group)=>{
     return CONSUMER_ROLES.includes(group);
 };
-export const isOwner = (group) => {
-    return [...OWNER_ROLES]?.map((r) => group === r)?.[0];
+export const isOwner = (group)=>{
+    return [
+        ...OWNER_ROLES
+    ]?.map((r)=>group === r)?.[0];
 };
-export const isAdmin = (group) => {
+export const isAdmin = (group)=>{
     return ALL_ADMIN_ROLES.includes(group);
 };

package/dist/authorization/index.js

@@ -4,15 +4,15 @@ import { ErrorWithResult } from '@driveflux/result';
 import { GUEST_PERMISSIONS } from './constants.js';
 import buildAbilityFromJson from './quick.js';
 import { updateUserPermissions } from './update-user-permissions.js';
-export const buildOrDefineAbility = async (user, refresh) => {
+export const buildOrDefineAbility = async (user, refresh)=>{
     if (!user) {
-        return createPrismaAbility([...GUEST_PERMISSIONS], {
-            detectSubjectType: detectSubjectType,
+        return createPrismaAbility([
+            ...GUEST_PERMISSIONS
+        ], {
+            detectSubjectType: detectSubjectType
         });
     }
-    if (!Array.isArray(user.permissions) ||
-        !user.permissions?.length ||
-        refresh) {
+    if (!Array.isArray(user.permissions) || !user.permissions?.length || refresh) {
         const result = await updateUserPermissions(user);
         if (result.err) {
             throw new ErrorWithResult(result);

package/dist/authorization/permissions-list.js

@@ -1,5 +1,5 @@
 import { s } from './utils.js';
-export const getPermissionsFromAbility = (ability) => {
+export const getPermissionsFromAbility = (ability)=>{
     return {
         // Lists
         viewContractsList: ability.can('read', 'SubscriptionContract'),
@@ -53,7 +53,7 @@ export const getPermissionsFromAbility = (ability) => {
         updateVehicleServiceCenters: ability.can('update', 'Vehicle', 'allowedServiceCenterIds'),
         readPricingInput: ability.can('readPricingInput', 'Vehicle'),
         updatePricingInput: ability.can('update', 'Vehicle', 'pricing'),
-        testPricingInput: ability.can('testPricingInput', 'Vehicle'), // Special Permission to allow users edit pricing but without the ability to update
+        testPricingInput: ability.can('testPricingInput', 'Vehicle'),
         // Users ( Members )
         createMember: ability.can('create', 'User'),
         updateMember: ability.can('update', s('User')),
@@ -84,8 +84,7 @@ export const getPermissionsFromAbility = (ability) => {
         updateInvoice: ability.can('update', s('Invoice', 'payerId')),
         cancelInvoice: ability.can('cancelInvoice', 'Invoice'),
         markInvoiceAsPaid: ability.can('markInvoice', 'Invoice', 'paid'),
-        markInvoiceAsRefunded: ability.can('markInvoice', 'Invoice', 'totalRefunded') &&
-            ability.can('create', 'Refund'),
+        markInvoiceAsRefunded: ability.can('markInvoice', 'Invoice', 'totalRefunded') && ability.can('create', 'Refund'),
         readPaymentMethodsUser: ability.can('read', s('User'), 'paymentMethods'),
         readPaymentMethodsBusiness: ability.can('read', s('Business'), 'paymentMethods'),
         addPaymentMethodUser: ability.can('update', s('User'), 'paymentMethods'),
@@ -133,8 +132,7 @@ export const getPermissionsFromAbility = (ability) => {
         // TODO add logs permision or remove the comments
         // Logs
         // Website Settings
-        uploadBanners: ability.can('update', 'PlatformConfig') &&
-            ability.can('create', 'PlatformConfig'),
+        uploadBanners: ability.can('update', 'PlatformConfig') && ability.can('create', 'PlatformConfig'),
         deleteBanners: ability.can('update', 'PlatformConfig'),
         // Quotations
         createQuotation: ability.can('create', 'Quotation'),
@@ -143,6 +141,6 @@ export const getPermissionsFromAbility = (ability) => {
         createVacancy: ability.can('create', 'Vacancy'),
         updateVacancy: ability.can('update', 'Vacancy'),
         readApplicant: ability.can('read', 'Applicant'),
-        readVacancy: ability.can('read', 'Vacancy'),
+        readVacancy: ability.can('read', 'Vacancy')
     };
 };

package/dist/authorization/quick.js

@@ -2,7 +2,7 @@ import { createPrismaAbility } from '@casl/prisma';
 import { detectSubjectType } from './utils.js';
 export function buildAbilityFromJson(user) {
     return createPrismaAbility(user.permissions, {
-        detectSubjectType,
+        detectSubjectType
     });
 }
 export default buildAbilityFromJson;

package/dist/authorization/roles/admin/business-development-executive.js

@@ -1,5 +1,5 @@
 import { getDocumentsFields } from '../../utils.js';
-export const defineRoleAbilitiesBusinessDevelopmentExecutive = async (can, cannot) => {
+export const defineRoleAbilitiesBusinessDevelopmentExecutive = async (can, cannot)=>{
     can('read', [
         'Subscription',
         'Vehicle',
@@ -13,22 +13,35 @@ export const defineRoleAbilitiesBusinessDevelopmentExecutive = async (can, canno
         'PaymentLink',
         'Invoice',
         'Transaction',
-        'Refund',
+        'Refund'
     ]);
     cannot('update', 'Invoice');
-    can('manage', ['Vehicle', 'ServiceCenter', 'Host', 'Inquiry', 'Token']);
+    can('manage', [
+        'Vehicle',
+        'ServiceCenter',
+        'Host',
+        'Inquiry',
+        'Token'
+    ]);
     can('readPricingInput', 'Vehicle');
     can('connectHostToStripe', 'Host');
-    can('update', 'Subscription', ['vehicleId']);
+    can('update', 'Subscription', [
+        'vehicleId'
+    ]);
     cannot('read', 'User', 'status');
     cannot('read', 'User', [
         ...getDocumentsFields('identification'),
         ...getDocumentsFields('drivingHistory'),
         ...getDocumentsFields('financial'),
-        ...getDocumentsFields('offerLetter'),
+        ...getDocumentsFields('offerLetter')
+    ]);
+    can([
+        'viewSubscriptionApproval'
+    ], 'Subscription');
+    cannot('read', [
+        'Vacancy',
+        'Applicant'
     ]);
-    can(['viewSubscriptionApproval'], 'Subscription');
-    cannot('read', ['Vacancy', 'Applicant']);
     can('read', 'Activity');
     can('read', 'ActivityTask');
 };

package/dist/authorization/roles/admin/ceo.js

@@ -1,3 +1,5 @@
-export const defineRoleAbilitiesCeo = async (can) => {
-    can(['manage'], 'all');
+export const defineRoleAbilitiesCeo = async (can)=>{
+    can([
+        'manage'
+    ], 'all');
 };

package/dist/authorization/roles/admin/common.js

@@ -1,9 +1,11 @@
-export const defineRoleAbilitiesCommonAdmin = async (can) => {
-    can(['read'], [
+export const defineRoleAbilitiesCommonAdmin = async (can)=>{
+    can([
+        'read'
+    ], [
         'Log',
         'Issue',
         'SubscriptionContract',
         'HostContribution',
-        'SubscriptionEvent',
+        'SubscriptionEvent'
     ]);
 };

package/dist/authorization/roles/admin/concierge.js

@@ -1,5 +1,5 @@
 import { getDocumentsFields } from '../../utils.js';
-export const defineRoleAbilitiesConcierge = async (can, cannot) => {
+export const defineRoleAbilitiesConcierge = async (can, cannot)=>{
     can('read', [
         'Subscription',
         'Cycle',
@@ -12,11 +12,14 @@ export const defineRoleAbilitiesConcierge = async (can, cannot) => {
         'Inquiry',
         'Discount',
         'PlatformConfig',
-        'PaymentLink',
+        'PaymentLink'
     ]);
     cannot('create', 'Business');
     can('manage', 'ServiceCenter');
-    can('update', 'Vehicle', ['images', 'allowedServiceCenterIds']);
+    can('update', 'Vehicle', [
+        'images',
+        'allowedServiceCenterIds'
+    ]);
     can('readPricingInput', 'Vehicle');
     can('update', 'Host', 'serviceCenterIds');
     can('manage', 'Subscription');
@@ -30,16 +33,38 @@ export const defineRoleAbilitiesConcierge = async (can, cannot) => {
         'payerType',
         'driversIds',
         'drivers',
-        'vehicleId',
+        'vehicleId'
+    ]);
+    can([
+        'read'
+    ], [
+        'Invoice',
+        'Transaction',
+        'Refund'
     ]);
-    can(['read'], ['Invoice', 'Transaction', 'Refund']);
     cannot('read', 'User', [
         ...getDocumentsFields('drivingHistory'),
         ...getDocumentsFields('financial'),
-        ...getDocumentsFields('offerLetter'),
+        ...getDocumentsFields('offerLetter')
+    ]);
+    can([
+        'manage'
+    ], [
+        'Activity',
+        'ActivityTask'
+    ]);
+    cannot([
+        'create',
+        'delete'
+    ], [
+        'Activity',
+        'ActivityTask'
+    ]);
+    can([
+        'viewSubscriptionApproval'
+    ], 'Subscription');
+    cannot('read', [
+        'Vacancy',
+        'Applicant'
     ]);
-    can(['manage'], ['Activity', 'ActivityTask']);
-    cannot(['create', 'delete'], ['Activity', 'ActivityTask']);
-    can(['viewSubscriptionApproval'], 'Subscription');
-    cannot('read', ['Vacancy', 'Applicant']);
 };