@driveflux/api-functions 1.0.116 → 1.0.118

package/dist/auth/tokens.js

@@ -1,17 +1,18 @@
 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;
     }
@@ -19,69 +20,72 @@ 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'));
             }
         }
@@ -103,30 +107,23 @@ 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,21 +3,19 @@ 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.`));
     }
@@ -34,18 +32,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);
             }
@@ -56,13 +54,15 @@ 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,122 +70,119 @@ 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;
 };
@@ -194,17 +191,19 @@ export const handleCheckDuplication = async (b)=>{
  * @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,3 +2,4 @@ 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,2 +1,3 @@
 import { createLogger } from '@driveflux/logger';
-export const createScopedLogger = (name)=>createLogger(`flux:api-functions:${name}`);
+export const createScopedLogger = (name) => createLogger(`flux:api-functions:${name}`);
+//# sourceMappingURL=create-logger.js.map

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,7 +21,8 @@ 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,15 +1,16 @@
 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,25 +1,24 @@
 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
-            }
-        }
-    }
-};
-export const refreshEmailPreferences = async (idOrUserForRefreshEmailPreferences)=>{
-    const user = typeof idOrUserForRefreshEmailPreferences === 'string' ? await prisma.user.findUnique({
-        where: {
-            id: idOrUserForRefreshEmailPreferences
+                active: true,
+            },
         },
-        ...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,3 +40,4 @@ 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
-            }
-        }
-    }
-};
-export const setContactInList = async (idOrUserForSetInContactListlPreferences, preferences)=>{
-    const user = typeof idOrUserForSetInContactListlPreferences === 'string' ? await prisma.user.findUnique({
-        where: {
-            id: idOrUserForSetInContactListlPreferences
+                active: true,
+            },
         },
-        ...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,3 +36,4 @@ 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 +1,2 @@
-export { };
+export {};
+//# sourceMappingURL=types.js.map

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,20 +6,18 @@ 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