@driveflux/api-functions 1.0.132 → 1.0.133

package/dist/auth/tokens.js

@@ -1,18 +1,17 @@
 import { prisma } from '@driveflux/db';
 import { generateId } from '@driveflux/db/id';
-import { makeProblem, PROBLEM_CORRUPT, PROBLEM_EXPIRED, PROBLEM_INVALID_DATA, PROBLEM_NOT_FOUND, } from '@driveflux/problem';
+import { makeProblem, PROBLEM_CORRUPT, PROBLEM_EXPIRED, PROBLEM_INVALID_DATA, PROBLEM_NOT_FOUND } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
 import { addDays } from 'date-fns/addDays';
 import { addMinutes } from 'date-fns/addMinutes';
 import { customAlphabet } from 'nanoid';
-export const createToken = async (userId, type, value, providedExpiresAt) => {
+export const createToken = async (userId, type, value, providedExpiresAt)=>{
     // Generate 6 digits
     const alphabet = '0123456789';
     const nanoid = customAlphabet(alphabet, 6);
     const identifier = !userId ? value : null;
     const scope = type === 'email' ? 'verify-email' : 'verify-phone';
-    const expiresAt = providedExpiresAt ||
-        (type === 'email' ? addDays(new Date(), 1) : addMinutes(new Date(), 30));
+    const expiresAt = providedExpiresAt || (type === 'email' ? addDays(new Date(), 1) : addMinutes(new Date(), 30));
     if (!userId && !identifier) {
         return;
     }
@@ -20,72 +19,69 @@ export const createToken = async (userId, type, value, providedExpiresAt) => {
         data: {
             id: generateId('Token'),
             value: nanoid(),
-            ...(userId
-                ? {
-                    user: {
-                        connect: {
-                            id: userId,
-                        },
-                    },
+            ...userId ? {
+                user: {
+                    connect: {
+                        id: userId
+                    }
                 }
-                : {}),
-            ...(identifier ? { identifier } : {}),
+            } : {},
+            ...identifier ? {
+                identifier
+            } : {},
             expiresAt,
             scope,
             metadata: {
-                [type]: value,
-            },
-        },
+                [type]: value
+            }
+        }
     });
 };
-export const createEmailToken = async (userId, email) => {
+export const createEmailToken = async (userId, email)=>{
     return await createToken(userId, 'email', email);
 };
-export const createSMSToken = async (userId, phoneNumber) => {
+export const createSMSToken = async (userId, phoneNumber)=>{
     return await createToken(userId, 'phoneNumber', phoneNumber);
 };
-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_NOT_FOUND, 'Token not found'));
     }
     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') {
         if (typeof verifications.metadata.phoneNumber !== 'undefined') {
-            const tokenPhoneNumber = token?.metadata &&
-                typeof token.metadata === 'object' &&
-                'phoneNumber' in token.metadata
-                ? token.metadata.phoneNumber
-                : undefined;
-            const formattedTokenPhoneNumber = `+${(tokenPhoneNumber)?.replace(/[^0-9]/g, '')}`;
+            const tokenPhoneNumber = token?.metadata && typeof token.metadata === 'object' && 'phoneNumber' in token.metadata ? token.metadata.phoneNumber : undefined;
+            const formattedTokenPhoneNumber = `+${tokenPhoneNumber?.replace(/[^0-9]/g, '')}`;
             const phoneNumber = verifications.metadata?.phoneNumber;
-            if (verifications.scope === 'verify-phone' &&
-                phoneNumber !== formattedTokenPhoneNumber &&
-                phoneNumber !== tokenPhoneNumber) {
+            if (verifications.scope === 'verify-phone' && phoneNumber !== formattedTokenPhoneNumber && phoneNumber !== tokenPhoneNumber) {
                 return new Err(makeProblem(PROBLEM_INVALID_DATA, 'Invalid token data'));
             }
         }
         if (typeof verifications.metadata.email !== 'undefined') {
-            const tokenEmail = token?.metadata &&
-                typeof token.metadata === 'object' &&
-                'email' in token.metadata
-                ? token.metadata.email
-                : undefined;
-            if (verifications.scope === 'verify-email' &&
-                tokenEmail !== verifications.metadata.email) {
+            const tokenEmail = token?.metadata && typeof token.metadata === 'object' && 'email' in token.metadata ? token.metadata.email : undefined;
+            if (verifications.scope === 'verify-email' && tokenEmail !== verifications.metadata.email) {
                 return new Err(makeProblem(PROBLEM_INVALID_DATA, 'Invalid token data'));
             }
         }
@@ -107,23 +103,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
+                }
+            ]
+        }
     });
 };
-//# sourceMappingURL=tokens.js.map

package/dist/auth/verifications.js

@@ -3,19 +3,21 @@ import { prisma } from '@driveflux/db';
 import { send } from '@driveflux/email';
 import { verificationEmail } from '@driveflux/email-templates/flux/verification';
 import { enhancedFetch } from '@driveflux/fetch';
-import { makeProblem, PROBLEM_CONFLICT, PROBLEM_EXTERNAL, PROBLEM_INTERNAL, PROBLEM_INVALID_DATA, PROBLEM_NOT_FOUND, PROBLEM_NOT_IMPLEMENTED, } from '@driveflux/problem';
+import { makeProblem, PROBLEM_CONFLICT, PROBLEM_EXTERNAL, PROBLEM_INTERNAL, PROBLEM_INVALID_DATA, PROBLEM_NOT_FOUND, PROBLEM_NOT_IMPLEMENTED } from '@driveflux/problem';
 import { reportProblem } from '@driveflux/reporter';
 import { Err, Ok } from '@driveflux/result';
 import { z } from 'zod';
 import { clearToken, createEmailToken, createSMSToken } from './tokens.js';
 const CheckDuplicationBody = z.object({
     phoneNumber: z.string(),
-    email: z.string().transform((email) => email.toLowerCase().trim()),
+    email: z.string().transform((email)=>email.toLowerCase().trim())
 });
-export const sendVerificationEmail = async (userId, temporaryEmail, next) => {
-    const user = typeof userId === 'string'
-        ? await prisma.user.findUnique({ where: { id: userId } })
-        : userId;
+export const sendVerificationEmail = async (userId, temporaryEmail, next)=>{
+    const user = typeof userId === 'string' ? await prisma.user.findUnique({
+        where: {
+            id: userId
+        }
+    }) : userId;
     if (!user) {
         return new Err(makeProblem(PROBLEM_NOT_FOUND, `User ${typeof userId === 'string' ? userId : 'unknown'} not found.`));
     }
@@ -32,18 +34,18 @@ export const sendVerificationEmail = async (userId, temporaryEmail, next) => {
     }
     const updatedUser = await prisma.user.update({
         where: {
-            id: user.id,
+            id: user.id
         },
         data: {
-            temporaryEmail: destinationEmail,
+            temporaryEmail: destinationEmail
         },
         include: {
-            tokens: true,
-        },
+            tokens: true
+        }
     });
     const tokens = updatedUser?.tokens;
     if (tokens) {
-        await Promise.allSettled(tokens.map(async (userToken) => {
+        await Promise.allSettled(tokens.map(async (userToken)=>{
             if (userToken.scope === 'verify-email' && userToken.id !== token.id) {
                 return await clearToken(userToken.id);
             }
@@ -54,15 +56,13 @@ export const sendVerificationEmail = async (userId, temporaryEmail, next) => {
     const query = new URLSearchParams({
         email: destinationEmail,
         token: token.id,
-        code: token.value,
+        code: token.value
     });
     if (next) {
         query.append('next', next);
     }
     const link = `${config.appUrl}/verify?${query}`;
-    const title = temporaryEmail
-        ? 'Confirm email change'
-        : 'Verify your email address';
+    const title = temporaryEmail ? 'Confirm email change' : 'Verify your email address';
     try {
         // Generate html
         const html = verificationEmail({
@@ -70,119 +70,122 @@ export const sendVerificationEmail = async (userId, temporaryEmail, next) => {
             link,
             title: `${title}`,
             newEmail: temporaryEmail,
-            isChanging: !!temporaryEmail,
+            isChanging: !!temporaryEmail
         });
         // send email
         const result = await send({
             to: {
                 name: user.firstName || '',
-                address: destinationEmail,
+                address: destinationEmail
             },
             subject: `${title}`,
-            html,
+            html
         });
         if (result.err) {
             console.error('Error sending email:', result.val);
             return new Err(makeProblem('email_not_sent', 'Unable to send the verification email'));
         }
-        return new Ok({ success: true, link });
-    }
-    catch (e) {
+        return new Ok({
+            success: true,
+            link
+        });
+    } catch (e) {
         return new Err(makeProblem('email_not_sent', e.message));
     }
 };
-export const verifyEmailUsage = async (newEmail) => {
+export const verifyEmailUsage = async (newEmail)=>{
     // TODO: add email regex checking
     if (newEmail.length < 3) {
         return new Err(makeProblem(PROBLEM_INVALID_DATA, 'Email address needs minimum 3 characters'));
     }
     const existingEmail = await prisma.user.findFirst({
         where: {
-            email: newEmail,
-        },
+            email: newEmail
+        }
     });
     if (existingEmail) {
         return new Err(makeProblem(PROBLEM_INVALID_DATA, 'The email address is already in use'));
     }
     return new Ok({});
 };
-export const sendVerificationSMS = async (userId, phoneNumber) => {
+export const sendVerificationSMS = async (userId, phoneNumber)=>{
     const token = await createSMSToken(userId, phoneNumber);
     if (!token) {
         return new Err(makeProblem(PROBLEM_NOT_IMPLEMENTED, 'Token was not created'));
     }
     return await sendSms(phoneNumber, token.value);
 };
-const formatPhoneNumber = (phoneNumber) => {
+const formatPhoneNumber = (phoneNumber)=>{
     return phoneNumber.replace(/[^0-9]/g, '');
 };
-const sendSms = async (phoneNumber, code) => {
+const sendSms = async (phoneNumber, code)=>{
     const isInternational = !formatPhoneNumber(phoneNumber).startsWith('60');
     try {
-        const sendSmsResult = isInternational
-            ? await sendVonageSms(phoneNumber, code)
-            : await sendEsmsSms(phoneNumber, code);
+        const sendSmsResult = isInternational ? await sendVonageSms(phoneNumber, code) : await sendEsmsSms(phoneNumber, code);
         if (sendSmsResult.err) {
             return new Err(await reportProblem(makeProblem({
                 type: 'public',
                 code: PROBLEM_EXTERNAL,
                 message: 'Unable to send sms verification',
                 privateMetadata: {
-                    error: sendSmsResult.val,
-                },
+                    error: sendSmsResult.val
+                }
             })));
         }
-        return new Ok({ success: true, code });
-    }
-    catch (e) {
+        return new Ok({
+            success: true,
+            code
+        });
+    } catch (e) {
         return new Err(await reportProblem(makeProblem({
             type: 'public',
             code: PROBLEM_INTERNAL,
             message: 'Unable to send sms verification',
             privateMetadata: {
-                error: e,
-            },
+                error: e
+            }
         })));
     }
 };
-export const handleCheckDuplication = async (b) => {
+export const handleCheckDuplication = async (b)=>{
     const { phoneNumber, email } = CheckDuplicationBody.parse(b);
     // Check if the user exists
     const checkForEmail = await prisma.user.findFirst({
         where: {
-            email: email.toLowerCase().trim(),
-        },
+            email: email.toLowerCase().trim()
+        }
     });
     if (checkForEmail) {
         return new Err(makeProblem(PROBLEM_CONFLICT, 'This email is already registered. Are you trying to sign in?'));
     }
     const checkForMobile = await prisma.user.findFirst({
         where: {
-            phoneNumber: phoneNumber.replace(/[\s-]/g, ''),
-        },
+            phoneNumber: phoneNumber.replace(/[\s-]/g, '')
+        }
     });
     if (checkForMobile) {
         return new Err(makeProblem(PROBLEM_CONFLICT, 'The phone number is already in use. Please try a different one.'));
     }
-    return new Ok({ notDuplicate: true });
+    return new Ok({
+        notDuplicate: true
+    });
 };
 /**
  * This function runs only for foreign numbers and sends an SMS containing the OTP code to the foreign number
  * @param phoneNumber user's phone number
  * @param code OTP code
  * @returns result of sending SMS to user
- */
-const sendVonageSms = async (phoneNumber, code) => {
+ */ const sendVonageSms = async (phoneNumber, code)=>{
     const body = {
         from: 'FLUX',
         to: formatPhoneNumber(phoneNumber),
         text: `FLUX verification code: ${code}`,
         api_key: config.vonage.apiKey,
-        api_secret: config.vonage.apiSecret,
+        api_secret: config.vonage.apiSecret
     };
     const result = await enhancedFetch('https://rest.nexmo.com/sms/json', {
         method: 'POST',
-        body: JSON.stringify(body),
+        body: JSON.stringify(body)
     });
     return result;
 };
@@ -191,19 +194,17 @@ const sendVonageSms = async (phoneNumber, code) => {
  * @param phoneNumber user's phone number
  * @param code OTP code
  * @returns result of sending SMS to user
- */
-const sendEsmsSms = async (phoneNumber, code) => {
+ */ const sendEsmsSms = async (phoneNumber, code)=>{
     const body = {
         user: config.esms.apiKey,
         pass: config.esms.apiSecret,
         to: formatPhoneNumber(phoneNumber),
         msg: `RM0.00 FLUX verification code: ${code}`,
-        sender: 'FLUX',
+        sender: 'FLUX'
     };
     const result = await enhancedFetch('https://api.esms.com.my/sms/send', {
         method: 'POST',
-        body: JSON.stringify(body),
+        body: JSON.stringify(body)
     });
     return result;
 };
-//# sourceMappingURL=verifications.js.map

package/dist/constants.js

@@ -2,4 +2,3 @@ export const TASK_PIPELINE_SLACK = 'slack-pipeline';
 export const TASK_COMMIT_SLACK_CHANNEL = 'commit-slack-channel';
 export const TASK_PIPELINE_SLACK_CRON = '* * * * *';
 export const SALT_ROUNDS = 12;
-//# sourceMappingURL=constants.js.map

package/dist/create-logger.js

@@ -1,3 +1,2 @@
 import { createLogger } from '@driveflux/logger';
-export const createScopedLogger = (name) => createLogger(`flux:api-functions:${name}`);
-//# sourceMappingURL=create-logger.js.map
+export const createScopedLogger = (name)=>createLogger(`flux:api-functions:${name}`);

package/dist/mailjet/calls/manage-contacts-in-list.js

@@ -3,16 +3,16 @@ import { Err } from '@driveflux/result';
 import { getListByRef } from '../utils/lists.js';
 import { callMailjet } from './request-service.js';
 // Add a contact to a contact list in Mailjet
-export const manageContactsInList = async ({ users, list, action = 'addnoforce', }) => {
-    const contacts = users.map((u) => {
+export const manageContactsInList = async ({ users, list, action = 'addnoforce' })=>{
+    const contacts = users.map((u)=>{
         return {
             Email: u.email,
             IsExcludedFromCampaigns: false,
             Name: `${u.firstName} ${u.lastName}`,
             Properties: {
                 FirstName: u.firstName,
-                LastName: u.lastName,
-            },
+                LastName: u.lastName
+            }
         };
     });
     const listOjbect = await getListByRef(list);
@@ -21,8 +21,7 @@ export const manageContactsInList = async ({ users, list, action = 'addnoforce',
     }
     const result = await callMailjet(`contactslist/${listOjbect.id}/managemanycontacts`, {
         Action: action,
-        Contacts: contacts,
+        Contacts: contacts
     });
     return result;
 };
-//# sourceMappingURL=manage-contacts-in-list.js.map

package/dist/mailjet/calls/manage-subscription-status.js

@@ -1,16 +1,15 @@
 import { getLists } from '../utils/lists.js';
 import { callMailjet } from './request-service.js';
-export const manageSubscriptionStatus = async (email, updatedLists) => {
+export const manageSubscriptionStatus = async (email, updatedLists)=>{
     const lists = await getLists();
     const data = {
-        ContactsLists: updatedLists.map((item) => {
+        ContactsLists: updatedLists.map((item)=>{
             return {
                 Action: item.action,
-                ListID: lists[item.list],
+                ListID: lists[item.list]
             };
-        }),
+        })
     };
     const result = await callMailjet(`/contact/${email}/managecontactslists`, data);
     return result;
 };
-//# sourceMappingURL=manage-subscription-status.js.map

package/dist/mailjet/calls/request-service.js

@@ -1,24 +1,25 @@
 import { config } from '@driveflux/email';
 import { enhancedFetch } from '@driveflux/fetch';
-const getAuth = () => {
+const getAuth = ()=>{
     const authData = {
         publicKey: config.mailjet.apiKeyPublic || process.env.MAILJET_API_KEY_PUBLIC,
-        privateKey: config.mailjet.apiKeyPrivate || process.env.MAILJET_API_KEY_PRIVATE,
+        privateKey: config.mailjet.apiKeyPrivate || process.env.MAILJET_API_KEY_PRIVATE
     };
     const authLine = `${authData.publicKey}:${authData.privateKey}`;
     return `Basic ${Buffer.from(authLine).toString('base64')}`;
 };
 const baseUrl = 'https://api.mailjet.com/v3/REST';
-export const callMailjet = async (path, data, method = 'POST') => {
+export const callMailjet = async (path, data, method = 'POST')=>{
     const url = `${baseUrl}${path}`;
     const result = await enhancedFetch(url, {
         method,
         headers: {
             'Content-Type': 'application/json',
-            Authorization: getAuth(),
+            Authorization: getAuth()
         },
-        ...(method !== 'GET' ? { body: JSON.stringify(data) } : {}),
+        ...method !== 'GET' ? {
+            body: JSON.stringify(data)
+        } : {}
     });
     return result;
 };
-//# sourceMappingURL=request-service.js.map

package/dist/mailjet/refresh-email-preferences.js

@@ -14,18 +14,18 @@ const userForRefreshEmailPreferencesQuery = {
         subscriptions: {
             select: {
                 ended: true,
-                active: true,
-            },
-        },
-    },
+                active: true
+            }
+        }
+    }
 };
-export const refreshEmailPreferences = async (idOrUserForRefreshEmailPreferences) => {
-    const user = typeof idOrUserForRefreshEmailPreferences === 'string'
-        ? await prisma.user.findUnique({
-            where: { id: idOrUserForRefreshEmailPreferences },
-            ...userForRefreshEmailPreferencesQuery,
-        })
-        : idOrUserForRefreshEmailPreferences;
+export const refreshEmailPreferences = async (idOrUserForRefreshEmailPreferences)=>{
+    const user = typeof idOrUserForRefreshEmailPreferences === 'string' ? await prisma.user.findUnique({
+        where: {
+            id: idOrUserForRefreshEmailPreferences
+        },
+        ...userForRefreshEmailPreferencesQuery
+    }) : idOrUserForRefreshEmailPreferences;
     if (!user) {
         return new Err(makeProblem(PROBLEM_NOT_FOUND, 'User not found'));
     }
@@ -40,4 +40,3 @@ export const refreshEmailPreferences = async (idOrUserForRefreshEmailPreferences
     const items = convertToArray(preferences, !!updated?.businessId);
     return await manageSubscriptionStatus(user.email, items);
 };
-//# sourceMappingURL=refresh-email-preferences.js.map

package/dist/mailjet/set-contact.js

@@ -13,18 +13,18 @@ const userForSetInContactListlPreferencesQuery = {
         subscriptions: {
             select: {
                 ended: true,
-                active: true,
-            },
-        },
-    },
+                active: true
+            }
+        }
+    }
 };
-export const setContactInList = async (idOrUserForSetInContactListlPreferences, preferences) => {
-    const user = typeof idOrUserForSetInContactListlPreferences === 'string'
-        ? await prisma.user.findUnique({
-            where: { id: idOrUserForSetInContactListlPreferences },
-            ...userForSetInContactListlPreferencesQuery,
-        })
-        : idOrUserForSetInContactListlPreferences;
+export const setContactInList = async (idOrUserForSetInContactListlPreferences, preferences)=>{
+    const user = typeof idOrUserForSetInContactListlPreferences === 'string' ? await prisma.user.findUnique({
+        where: {
+            id: idOrUserForSetInContactListlPreferences
+        },
+        ...userForSetInContactListlPreferencesQuery
+    }) : idOrUserForSetInContactListlPreferences;
     if (!user) {
         return new Err(makeProblem(PROBLEM_NOT_FOUND, 'User not found'));
     }
@@ -36,4 +36,3 @@ export const setContactInList = async (idOrUserForSetInContactListlPreferences,
     const results = await manageSubscriptionStatus(user.email, items);
     return new Ok(results);
 };
-//# sourceMappingURL=set-contact.js.map

package/dist/mailjet/types.js

@@ -1,2 +1 @@
-export {};
-//# sourceMappingURL=types.js.map
+export { };

package/dist/mailjet/utils/convert-to-array.js

@@ -1,4 +1,4 @@
-export const convertToArray = (preferences, isBusiness) => {
+export const convertToArray = (preferences, isBusiness)=>{
     if (!preferences) {
         return [];
     }
@@ -6,18 +6,20 @@ export const convertToArray = (preferences, isBusiness) => {
     if (typeof isBusiness === 'boolean') {
         preferencesArray.push([
             'activeSubBusiness',
-            !!preferences?.activeSub && isBusiness,
+            !!preferences?.activeSub && isBusiness
         ]);
         preferencesArray.push([
             'activeSubPersonal',
-            !!preferences?.activeSub && !isBusiness,
+            !!preferences?.activeSub && !isBusiness
         ]);
     }
-    const items = preferencesArray.map(([key, value]) => {
+    const items = preferencesArray.map(([key, value])=>{
         const list = key;
         const action = value ? 'addnoforce' : 'unsub';
-        return { list, action };
+        return {
+            list,
+            action
+        };
     });
     return items;
 };
-//# sourceMappingURL=convert-to-array.js.map