@driveflux/auth 4.0.63 → 4.0.64

package/dist/authorization/roles/admin/sales-executive.js

@@ -1,5 +1,5 @@
 import { getDocumentsFields, getPricingFields } from '../../utils.js';
-export const defineRoleAbilitiesSalesExecutive = async (can, cannot)=>{
+export const defineRoleAbilitiesSalesExecutive = async (can, cannot) => {
     can('read', [
         'Subscription',
         'Cycle',
@@ -9,26 +9,16 @@ export const defineRoleAbilitiesSalesExecutive = async (can, cannot)=>{
         'Host',
         'Discount',
         'PlatformConfig',
-        'PaymentLink'
+        'PaymentLink',
     ]);
-    can([
-        'read',
-        'update'
-    ], [
-        'Invoice',
-        'Transaction',
-        'Refund'
-    ]);
-    can([
-        'read',
-        'update'
-    ], 'User');
+    can(['read', 'update'], ['Invoice', 'Transaction', 'Refund']);
+    can(['read', 'update'], 'User');
     cannot('update', 'User', 'status');
     cannot('update', 'User', [
         ...getDocumentsFields('identification'),
         ...getDocumentsFields('drivingHistory'),
         ...getDocumentsFields('financial'),
-        ...getDocumentsFields('offerLetter')
+        ...getDocumentsFields('offerLetter'),
     ]);
     can('manage', 'Business');
     can('manage', 'Inquiry');
@@ -39,23 +29,17 @@ export const defineRoleAbilitiesSalesExecutive = async (can, cannot)=>{
         'endedAt',
         'plan',
         'mileagePackage',
-        'payerType'
+        'payerType',
     ]);
     can('read', 'SubscriptionReservation');
-    cannot('update', 'Subscription', [
-        'status',
-        'started'
-    ]);
+    cannot('update', 'Subscription', ['status', 'started']);
     cannot('update', 'Vehicle', getPricingFields());
     can('testPricingInput', 'Vehicle');
     can('readPricingInput', 'Vehicle');
     cannot('cancelInvoice', 'Invoice');
     cannot('markInvoice', 'Invoice');
     cannot('delete', 'Quotation');
-    cannot('read', [
-        'Vacancy',
-        'Applicant'
-    ]);
+    cannot('read', ['Vacancy', 'Applicant']);
     can('read', 'Activity');
     can('read', 'ActivityTask');
 };

package/dist/authorization/roles/consumer/business-admin.js

@@ -1,25 +1,12 @@
-export const defineRoleAbilitiesBusinessAdmin = async (can, user)=>{
+export const defineRoleAbilitiesBusinessAdmin = async (can, user) => {
     if (!user.businessId) {
         return;
     }
-    can([
-        'read',
-        'update'
-    ], 'User', {
-        businessId: user.businessId
-    });
-    can('read', 'Subscription', {
-        businessId: user.businessId
-    });
-    can('update', 'Business', [
-        'phoneNumber',
-        'mobileNumber',
-        'addresses'
-    ], {
-        id: user.businessId
-    });
-    can('read', 'Business', {
-        id: user.businessId
+    can(['read', 'update'], 'User', { businessId: user.businessId });
+    can('read', 'Subscription', { businessId: user.businessId });
+    can('update', 'Business', ['phoneNumber', 'mobileNumber', 'addresses'], {
+        id: user.businessId,
     });
+    can('read', 'Business', { id: user.businessId });
     can('create', 'Mandate');
 };

package/dist/authorization/roles/consumer/business-user.js

@@ -1,24 +1,12 @@
-export const defineRoleAbilitiesBusinessUser = async (can, user)=>{
+export const defineRoleAbilitiesBusinessUser = async (can, user) => {
     if (!user.businessId) {
         return;
     }
-    can([
-        'read'
-    ], 'User', {
-        businessId: user.businessId
-    });
-    can('read', 'Subscription', {
-        businessId: user.businessId
-    });
-    can('update', 'Business', [
-        'phoneNumber',
-        'mobileNumber',
-        'addresses'
-    ], {
-        id: user.businessId
-    });
-    can('read', 'Business', {
-        id: user.businessId
+    can(['read'], 'User', { businessId: user.businessId });
+    can('read', 'Subscription', { businessId: user.businessId });
+    can('update', 'Business', ['phoneNumber', 'mobileNumber', 'addresses'], {
+        id: user.businessId,
     });
+    can('read', 'Business', { id: user.businessId });
     can('create', 'Mandate');
 };

package/dist/authorization/roles/consumer/member.js

@@ -1,4 +1,4 @@
-export const defineRoleAbilitiesMember = async (can, user)=>{
+export const defineRoleAbilitiesMember = async (can, user) => {
     can('read', 'Cycle', [
         'id',
         'startDate',
@@ -6,23 +6,13 @@ export const defineRoleAbilitiesMember = async (can, user)=>{
         'utilization.pricePerKm',
         'utilization.paid',
         'utilization.allowedMileage',
-        'utilization.mileage'
-    ], {
-        subscription: {
-            userId: user.id
-        }
-    });
-    can('read', 'Vehicle', {
-        status: 'listed'
-    });
+        'utilization.mileage',
+    ], { subscription: { userId: user.id } });
+    can('read', 'Vehicle', { status: 'listed' });
     can('create', 'Business');
     if (user.businessId) {
-        can('update', 'Business', {
-            id: user.businessId
-        });
+        can('update', 'Business', { id: user.businessId });
     }
-    can('read', 'Subscription', {
-        userId: user.id
-    });
+    can('read', 'Subscription', { userId: user.id });
     can('read', 'Coupon');
 };

package/dist/authorization/types.js

@@ -1 +1 @@
-export { };
+export {};

package/dist/authorization/update-user-permissions.js

@@ -2,39 +2,32 @@ import { prisma } from '@driveflux/db';
 import { makeProblem, PROBLEM_NOT_FOUND } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
 import { defineAbilityFor } from './define.js';
-export const updateUserPermissions = async (userId, newGroups)=>{
-    const user = typeof userId === 'string' ? await prisma.user.findUnique({
-        where: {
-            id: userId
-        }
-    }) : userId;
+export const updateUserPermissions = async (userId, newGroups) => {
+    const user = typeof userId === 'string'
+        ? await prisma.user.findUnique({
+            where: {
+                id: userId,
+            },
+        })
+        : userId;
     if (!user) {
         return new Err(makeProblem(PROBLEM_NOT_FOUND, 'User not found when trying to update the permissions'));
     }
-    const groups = newGroups ? [
-        ...newGroups
-    ] : [
-        ...user.groups
-    ];
+    const groups = newGroups ? [...newGroups] : [...user.groups];
     const ability = await defineAbilityFor({
         ...user,
-        groups
+        groups,
     });
     await prisma.user.update({
         where: {
-            id: user.id
+            id: user.id,
         },
         data: {
-            groups: [
-                ...groups
-            ],
-            permissions: ability.rules
-        }
+            groups: [...groups],
+            permissions: ability.rules,
+        },
     });
     user.groups = groups;
     user.permissions = ability.rules;
-    return new Ok({
-        user,
-        ability
-    });
+    return new Ok({ user, ability });
 };

package/dist/authorization/utils.js

@@ -1,37 +1,25 @@
 import { subject } from '@casl/ability';
 import { pascalCase } from 'change-case';
-export const detectSubjectType = (subject)=>{
+export const detectSubjectType = (subject) => {
     if (!('object' in subject)) {
         throw new Error(`Trying to get an object from model ${subject} that is not a real model`);
     }
     return pascalCase(subject.object);
 };
 const documents = {
-    identification: [
-        'visa',
-        'passport',
-        'idFront',
-        'idBack',
-        'drivingLicense'
-    ],
-    drivingHistory: [
-        'pdrm',
-        'jpj',
-        'bgs'
-    ],
+    identification: ['visa', 'passport', 'idFront', 'idBack', 'drivingLicense'],
+    drivingHistory: ['pdrm', 'jpj', 'bgs'],
     financial: [
         'experianReport',
         'bankStatement',
         'bankStatement2',
         'bankStatement3',
-        'epfStatement'
+        'epfStatement',
     ],
-    offerLetter: [
-        'offerLetter'
-    ]
+    offerLetter: ['offerLetter'],
 };
-export const getDocumentsFields = (documentsGroup)=>documents[documentsGroup].map((d)=>`documents.${d}`);
-export const getPricingFields = ()=>{
+export const getDocumentsFields = (documentsGroup) => documents[documentsGroup].map((d) => `documents.${d}`);
+export const getPricingFields = () => {
     return [
         'pricing',
         'basePrice',
@@ -39,17 +27,14 @@ export const getPricingFields = ()=>{
         'basePricePlan12',
         'basePricePlan24',
         'basePricePlan36',
-        'basePricePlan60'
+        'basePricePlan60',
     ];
 };
 // we are creating a helper function to fake an object
-export const s = (modelName, key = 'id')=>{
+export const s = (modelName, key = 'id') => {
     const objectName = getObjectName(modelName);
-    return subject(modelName, {
-        object: objectName,
-        [key]: 'XXXXXXXXX'
-    });
+    return subject(modelName, { object: objectName, [key]: 'XXXXXXXXX' });
 };
-const getObjectName = (modelName)=>{
+const getObjectName = (modelName) => {
     return modelName[0].toLowerCase() + modelName.slice(1);
 };

package/dist/constants.d.ts

@@ -1,9 +1,9 @@
-export declare const AUTH_COOKIE_PREFIX = "flux-auth";
-export declare const AUTH_COOKIE_ACCESSED_ADMIN = "flux-auth.has-accessed-admin";
-export declare const AUTH_COOKIE_SESSION_TOKEN = "flux-auth.session-token";
-export declare const AUTH_COOKIE_CALLBACK_URL = "flux-auth.callback-url";
-export declare const AUTH_COOKIE_CSRF_TOKEN = "flux-auth.csrf-token";
-export declare const AUTH_COOKIE_PKCE_CODE_VERIFIER = "flux-auth.pkce.code_verifier";
-export declare const AUTH_COOKIE_STATE = "flux-auth.state";
-export declare const AUTH_COOKIE_NONCE = "flux-auth.nonce";
+export declare const AUTH_COOKIE_PREFIX: string;
+export declare const AUTH_COOKIE_ACCESSED_ADMIN: string;
+export declare const AUTH_COOKIE_SESSION_TOKEN: string;
+export declare const AUTH_COOKIE_CALLBACK_URL: string;
+export declare const AUTH_COOKIE_CSRF_TOKEN: string;
+export declare const AUTH_COOKIE_PKCE_CODE_VERIFIER: string;
+export declare const AUTH_COOKIE_STATE: string;
+export declare const AUTH_COOKIE_NONCE: string;
 export declare const PROBLEM_INVALID_LOGIN = "invalid_credentials";

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,cAAc,CAAA;AAC7C,eAAO,MAAM,0BAA0B,iCAA6C,CAAA;AACpF,eAAO,MAAM,yBAAyB,4BAAwC,CAAA;AAC9E,eAAO,MAAM,wBAAwB,2BAAuC,CAAA;AAC5E,eAAO,MAAM,sBAAsB,yBAAqC,CAAA;AACxE,eAAO,MAAM,8BAA8B,iCAA6C,CAAA;AACxF,eAAO,MAAM,iBAAiB,oBAAgC,CAAA;AAC9D,eAAO,MAAM,iBAAiB,oBAAgC,CAAA;AAC9D,eAAO,MAAM,qBAAqB,wBAAwB,CAAA"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,QAEjB,CAAA;AAEd,eAAO,MAAM,0BAA0B,QAA6C,CAAA;AACpF,eAAO,MAAM,yBAAyB,QAAwC,CAAA;AAC9E,eAAO,MAAM,wBAAwB,QAAuC,CAAA;AAC5E,eAAO,MAAM,sBAAsB,QAAqC,CAAA;AACxE,eAAO,MAAM,8BAA8B,QAA6C,CAAA;AACxF,eAAO,MAAM,iBAAiB,QAAgC,CAAA;AAC9D,eAAO,MAAM,iBAAiB,QAAgC,CAAA;AAC9D,eAAO,MAAM,qBAAqB,wBAAwB,CAAA"}

package/dist/constants.js

@@ -1,4 +1,7 @@
-export const AUTH_COOKIE_PREFIX = 'flux-auth';
+const envSuffux = process.env.APP_ENV === 'production' ? '' : (process.env.APP_ENV ?? '');
+export const AUTH_COOKIE_PREFIX = envSuffux
+    ? `flux-auth.${envSuffux}`
+    : 'flux-auth';
 export const AUTH_COOKIE_ACCESSED_ADMIN = `${AUTH_COOKIE_PREFIX}.has-accessed-admin`;
 export const AUTH_COOKIE_SESSION_TOKEN = `${AUTH_COOKIE_PREFIX}.session-token`;
 export const AUTH_COOKIE_CALLBACK_URL = `${AUTH_COOKIE_PREFIX}.callback-url`;

package/dist/context.js

@@ -2,15 +2,16 @@ import { createContext } from 'react';
 const defaultContext = {
     user: undefined,
     isLoadingUser: false,
-    signIn: async ()=>Promise.resolve(undefined),
-    refresh: async ()=>Promise.resolve(undefined),
+    signIn: async () => Promise.resolve(undefined),
+    refresh: async () => Promise.resolve(undefined),
     /**
-	 *
-	 * @deprecated There's no need for access token anymore, we use cookies
-	 */ getAccessToken: async ()=>Promise.resolve(undefined),
+     *
+     * @deprecated There's no need for access token anymore, we use cookies
+     */
+    getAccessToken: async () => Promise.resolve(undefined),
     // TODO
     // eslint-disable-next-line @typescript-eslint/no-empty-function -- initial state
-    logout: ()=>{},
-    status: 'loading'
+    logout: () => { },
+    status: 'loading',
 };
-export const AuthContext = /*#__PURE__*/ createContext(defaultContext);
+export const AuthContext = createContext(defaultContext);

package/dist/default.js

@@ -1,4 +1,4 @@
-export const extractDefault = (mod)=>{
+export const extractDefault = (mod) => {
     if (typeof mod === 'object' && mod !== null && 'default' in mod) {
         return mod.default;
     }

package/dist/server/authenticate-user.js

@@ -5,29 +5,25 @@ import bcrypt from 'bcryptjs';
 import { PROBLEM_INVALID_LOGIN } from '../constants.js';
 import { translations } from '../translations.js';
 import { verifyToken } from './verfiy-token.js';
-export const authenticateUser = async ({ login, password })=>{
+export const authenticateUser = async ({ login, password, }) => {
     const isEmail = login.includes('@');
     // Check if the user exists
     const user = await prisma.user.findFirst({
         where: {
-            ...isEmail ? {
-                email: login.toLowerCase().trim()
-            } : {
-                phoneNumber: login.replace(/[\s-]/g, '')
-            }
-        }
+            ...(isEmail
+                ? { email: login.toLowerCase().trim() }
+                : { phoneNumber: login.replace(/[\s-]/g, '') }),
+        },
     });
     if (!user) {
         return new Err(makeProblem(PROBLEM_INVALID_LOGIN, translations.wrongUsernameOrPassword));
     }
     // Check the user's password
-    if (isEmail && !await bcrypt.compare(password, user.password)) {
+    if (isEmail && !(await bcrypt.compare(password, user.password))) {
         return new Err(makeProblem(PROBLEM_INVALID_LOGIN, 'The email / password combination is invalid.'));
     }
     if (!isEmail) {
-        const tokenResult = await verifyToken(password, {
-            scope: 'verify-phone'
-        });
+        const tokenResult = await verifyToken(password, { scope: 'verify-phone' });
         if (!tokenResult.ok) {
             return new Err(makeProblem(PROBLEM_INVALID_LOGIN, 'The OTP is invalid.'));
         }

package/dist/server/cors.js

@@ -1,39 +1,28 @@
 import { config } from '@driveflux/config/backend';
 import Cors from 'cors';
 const corsOptions = {
-    origin: (origin, callback)=>{
-        const allowedOrigins = [
-            config.appUrl
-        ];
-        if (config.appEnv === 'development' || origin && allowedOrigins.includes(origin)) {
+    origin: (origin, callback) => {
+        const allowedOrigins = [config.appUrl];
+        if (config.appEnv === 'development' ||
+            (origin && allowedOrigins.includes(origin))) {
             callback(null, true);
-        } else {
+        }
+        else {
             callback(new Error('CORS not allowed'));
         }
     },
-    allowedHeaders: [
-        'content-type',
-        'x-correlation-id',
-        'authorization'
-    ],
+    allowedHeaders: ['content-type', 'x-correlation-id', 'authorization'],
     exposedHeaders: '*',
-    methods: [
-        'GET',
-        'HEAD',
-        'PUT',
-        'PATCH',
-        'POST',
-        'DELETE'
-    ],
-    credentials: true
+    methods: ['GET', 'HEAD', 'PUT', 'PATCH', 'POST', 'DELETE'],
+    credentials: true,
 };
 // Initializing the cors middleware
 // I don't have time to debug cors now, I've got a million things to do.
 // TODO Implement this properly please
 const corsHandler = config.appEnv === 'development' ? Cors(corsOptions) : Cors();
-export const cors = (req, res)=>{
-    return new Promise((resolve, reject)=>{
-        corsHandler(req, res, (result)=>{
+export const cors = (req, res) => {
+    return new Promise((resolve, reject) => {
+        corsHandler(req, res, (result) => {
             if (result instanceof Error) {
                 return reject(result);
             }

package/dist/server/credentials-provider.js

@@ -4,7 +4,7 @@ export function Credentials(options) {
         name: 'Credentials',
         type: 'flux-credentials',
         credentials: {},
-        authorize: ()=>null,
-        options
+        authorize: () => null,
+        options,
     };
 }

package/dist/server/next-auth.d.ts

@@ -37,7 +37,7 @@ export declare const authOptions: {
             };
             credentials?: Record<string, import("next-auth/providers/credentials").CredentialInput>;
         }) => Promise<boolean>;
-        readonly session: ({ session, user, trigger, token, ...others }: {
+        readonly session: ({ session, user, trigger }: {
             session: import("next-auth").Session;
             token: import("next-auth/jwt").JWT;
             user: import("next-auth/adapters").AdapterUser;
@@ -358,7 +358,7 @@ export declare const authOptions: {
     };
     readonly cookies: {
         readonly sessionToken: {
-            readonly name: "flux-auth.session-token";
+            readonly name: string;
             readonly options: {
                 readonly httpOnly: true;
                 readonly sameSite: "lax";
@@ -368,7 +368,7 @@ export declare const authOptions: {
             };
         };
         readonly callbackUrl: {
-            readonly name: "flux-auth.callback-url";
+            readonly name: string;
             readonly options: {
                 readonly httpOnly: true;
                 readonly sameSite: "lax";
@@ -377,7 +377,7 @@ export declare const authOptions: {
             };
         };
         readonly csrfToken: {
-            readonly name: "flux-auth.csrf-token" | "__Host-flux-auth.csrf-token";
+            readonly name: string;
             readonly options: {
                 readonly httpOnly: true;
                 readonly sameSite: "lax";
@@ -386,7 +386,7 @@ export declare const authOptions: {
             };
         };
         readonly pkceCodeVerifier: {
-            readonly name: "flux-auth.pkce.code_verifier";
+            readonly name: string;
             readonly options: {
                 readonly httpOnly: true;
                 readonly sameSite: "lax";
@@ -396,7 +396,7 @@ export declare const authOptions: {
             };
         };
         readonly state: {
-            readonly name: "flux-auth.state";
+            readonly name: string;
             readonly options: {
                 readonly httpOnly: true;
                 readonly sameSite: "lax";
@@ -406,7 +406,7 @@ export declare const authOptions: {
             };
         };
         readonly nonce: {
-            readonly name: "flux-auth.nonce";
+            readonly name: string;
             readonly options: {
                 readonly httpOnly: true;
                 readonly sameSite: "lax";

package/dist/server/next-auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"next-auth.d.ts","sourceRoot":"","sources":["../../src/server/next-auth.ts"],"names":[],"mappings":"AAEA,OAAO,qBAAqB,CAAA;AAK5B,OAAO,KAAK,EAAE,IAAI,IAAI,WAAW,EAAmB,MAAM,WAAW,CAAA;AA4BrE,eAAO,MAAM,oBAAoB,GAChC,MAAM,WAAW,KACf,OAAO,CAAC,MAAM,CAehB,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;2BAQlB,MAAM,CAAC,UAAU,GAAG,OAAO,EAAE,MAAM,CAAC,GAAG,SAAS,GAC3D,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;CAQ/B,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;mCAyRijG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADtiG,CAAA"}
+{"version":3,"file":"next-auth.d.ts","sourceRoot":"","sources":["../../src/server/next-auth.ts"],"names":[],"mappings":"AAEA,OAAO,qBAAqB,CAAA;AAK5B,OAAO,KAAK,EAAE,IAAI,IAAI,WAAW,EAAmB,MAAM,WAAW,CAAA;AA6BrE,eAAO,MAAM,oBAAoB,GAChC,MAAM,WAAW,KACf,OAAO,CAAC,MAAM,CAehB,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;2BAQlB,MAAM,CAAC,UAAU,GAAG,OAAO,EAAE,MAAM,CAAC,GAAG,SAAS,GAC3D,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;CAQ/B,CAAA;AAED,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;mCA+S24E,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADh4E,CAAA"}