@driveflux/api-functions 1.0.118 → 1.0.119

package/dist/auth/confirm.js

@@ -13,35 +13,34 @@ const Body = z.object({
     firstName: z.string(),
     lastName: z.string(),
     email: z.string(),
-    phoneNumber: z.string().transform((s) => s.replace(/[\s-]/g, '')),
+    phoneNumber: z.string().transform((s)=>s.replace(/[\s-]/g, '')),
     code: z.string().optional().nullable(),
     pageSource: z.string().optional().nullable(),
     fingerprint: z.string().optional(),
     ipAddress: z.string(),
-    userAgent: z.string().optional(),
+    userAgent: z.string().optional()
 });
-export const handleConfirmUser = async (b, user) => {
+export const handleConfirmUser = async (b, user)=>{
     const { phoneNumber, code, pageSource, fingerprint, ipAddress, userAgent, ...body } = Body.parse(b);
     console.log('fingerprint in handle confirm user???', fingerprint);
     let phoneNumberVerified = false;
     if (code) {
-        const tokenResult = await verifyToken(code, { scope: 'verify-phone' });
+        const tokenResult = await verifyToken(code, {
+            scope: 'verify-phone'
+        });
         if (tokenResult.err) {
             return new Err(makeProblem(PROBLEM_CONFLICT, 'Invalid OTP token'));
         }
         await clearToken(tokenResult.val.id);
         phoneNumberVerified = true;
-    }
-    else {
+    } else {
         phoneNumberVerified = user.phoneNumberVerified;
     }
-    const method = isMetadata(user?.metadata)
-        ? user?.metadata?.signupProvider
-        : undefined;
+    const method = isMetadata(user?.metadata) ? user?.metadata?.signupProvider : undefined;
     const tokenId = generateId('Token');
     const updatedUser = await prisma.user.update({
         where: {
-            id: user.id,
+            id: user.id
         },
         data: {
             ...body,
@@ -49,18 +48,20 @@ export const handleConfirmUser = async (b, user) => {
             preferredCurrency: 'MYR',
             preferredLocale: 'en',
             phoneNumberVerified,
-            groups: ['member'],
+            groups: [
+                'member'
+            ],
             signupParams: {
                 method,
-                source: pageSource,
+                source: pageSource
             },
             registrationComplete: true,
             tokens: {
                 create: {
                     id: tokenId,
                     expiresAt: addDays(new Date(), 365),
-                    scope: 'all',
-                },
+                    scope: 'all'
+                }
             },
             consented: true,
             consents: {
@@ -69,31 +70,30 @@ export const handleConfirmUser = async (b, user) => {
                         ...user,
                         phoneNumber,
                         firstName: body.firstName,
-                        lastName: body.lastName,
+                        lastName: body.lastName
                     },
                     fingerprint,
                     termsVersion: 'universal',
                     ipAddress: ipAddress,
                     userAgent: userAgent,
                     sessionToken: tokenId,
-                    consentType: 'terms',
-                }),
-            },
+                    consentType: 'terms'
+                })
+            }
         },
         include: {
             tokens: {
                 where: {
-                    id: tokenId,
-                },
-            },
-        },
+                    id: tokenId
+                }
+            }
+        }
     });
     // We don't want this to be a task. It should be instant
     await sendVerificationEmail(updatedUser.id);
     await refreshEmailPreferences(updatedUser.id);
     return new Ok({
         token: updatedUser.tokens[0],
-        user: updatedUser,
+        user: updatedUser
     });
 };
-//# sourceMappingURL=confirm.js.map

package/dist/auth/consent.js

@@ -1,58 +1,53 @@
 import { prisma } from '@driveflux/db';
 import { generateId } from '@driveflux/db/id';
-export const getConsentCreateData = ({ fingerprint, termsVersion, ipAddress, userAgent, user, sessionToken, sessionId, consentType, }) => {
+export const getConsentCreateData = ({ fingerprint, termsVersion, ipAddress, userAgent, user, sessionToken, sessionId, consentType })=>{
     const consentCreate = {
         id: generateId('UserConsent'),
         ipAddress,
         consentType: consentType || 'terms',
         sessionToken,
-        userName: [user.firstName, user.lastName].filter(Boolean).join(' '),
+        userName: [
+            user.firstName,
+            user.lastName
+        ].filter(Boolean).join(' '),
         phoneNumber: user.phoneNumber,
         email: user.email,
         fingerprint,
         user: {
             connect: {
-                id: user.id,
-            },
+                id: user.id
+            }
         },
-        ...(sessionId
-            ? {
-                session: {
-                    connect: {
-                        id: sessionId,
-                    },
-                },
+        ...sessionId ? {
+            session: {
+                connect: {
+                    id: sessionId
+                }
             }
-            : undefined),
+        } : undefined,
         userAgent,
-        termsVersion: termsVersion || 'universal',
+        termsVersion: termsVersion || 'universal'
     };
     return consentCreate;
 };
-export const createConsent = (data) => {
+export const createConsent = (data)=>{
     const consentData = getConsentCreateData(data);
     return prisma.userConsent.create({
-        data: consentData,
+        data: consentData
     });
 };
-export const shouldConsentAgain = (consent) => {
-    return (!consent.userAgent ||
-        !consent.ipAddress ||
-        consent.ipAddress === '0.0.0.0' ||
-        !consent.userName ||
-        !consent.phoneNumber ||
-        !consent.email);
+export const shouldConsentAgain = (consent)=>{
+    return !consent.userAgent || !consent.ipAddress || consent.ipAddress === '0.0.0.0' || !consent.userName || !consent.phoneNumber || !consent.email;
 };
-export const checkUserConsent = async (userId) => {
+export const checkUserConsent = async (userId)=>{
     const consent = await prisma.userConsent.findFirst({
         where: {
             userId,
-            consentType: 'terms',
+            consentType: 'terms'
         },
         orderBy: {
-            createdAt: 'desc',
-        },
+            createdAt: 'desc'
+        }
     });
     return consent && !shouldConsentAgain(consent);
 };
-//# sourceMappingURL=consent.js.map

package/dist/auth/emails.js

@@ -4,11 +4,11 @@ import { emailChangedEmail } from '@driveflux/email-templates/flux/email-changed
 import { passwordChangedEmail } from '@driveflux/email-templates/flux/password-changed';
 import { makeProblem, PROBLEM_NOT_FOUND } from '@driveflux/problem';
 import { Err } from '@driveflux/result';
-export const sendEmailChangedEmail = async (userId) => {
+export const sendEmailChangedEmail = async (userId)=>{
     const user = await prisma.user.findUnique({
         where: {
-            id: userId,
-        },
+            id: userId
+        }
     });
     if (!user) {
         return new Err(makeProblem(PROBLEM_NOT_FOUND, `The user ${userId} was not found`));
@@ -17,20 +17,20 @@ export const sendEmailChangedEmail = async (userId) => {
         subject: 'Email change confirmation',
         to: {
             name: user.firstName || '',
-            address: user.email,
+            address: user.email
         },
         html: emailChangedEmail({
             user: user.firstName || '',
             title: 'Email change confirmation',
-            newEmail: user.email,
-        }),
+            newEmail: user.email
+        })
     });
 };
-export const sendPasswordChangedEmail = async (userId) => {
+export const sendPasswordChangedEmail = async (userId)=>{
     const user = await prisma.user.findUnique({
         where: {
-            id: userId,
-        },
+            id: userId
+        }
     });
     if (!user) {
         return new Err(makeProblem(PROBLEM_NOT_FOUND, `The user ${userId} was not found`));
@@ -40,12 +40,11 @@ export const sendPasswordChangedEmail = async (userId) => {
         subject: title,
         to: {
             name: user.firstName || '',
-            address: user.email,
+            address: user.email
         },
         html: passwordChangedEmail({
             user: user.firstName || '',
-            title: title,
-        }),
+            title: title
+        })
     });
 };
-//# sourceMappingURL=emails.js.map

package/dist/auth/formatter.js

@@ -221,9 +221,9 @@ const knownCountryCodes = [
     '246',
     '269',
     '692',
-    '383',
+    '383'
 ];
-export const cleanupPhoneNumber = (phoneNumber) => {
+export const cleanupPhoneNumber = (phoneNumber)=>{
     // Remove all characters except numbers and +
     const cleaned = phoneNumber.replace(/[^\d+]/g, '');
     // If it doesn't start with +, add it
@@ -232,8 +232,9 @@ export const cleanupPhoneNumber = (phoneNumber) => {
     let countryCode = '';
     let remainingNumber = '';
     // Try to find the country code by checking the longest matches first
-    for (let i = 4; i >= 1; i--) {
-        const potentialCode = withPlus.substring(1, 1 + i); // Skip the + and take i digits
+    for(let i = 4; i >= 1; i--){
+        const potentialCode = withPlus.substring(1, 1 + i) // Skip the + and take i digits
+        ;
         if (knownCountryCodes.includes(potentialCode)) {
             countryCode = potentialCode;
             remainingNumber = withPlus.substring(1 + i); // Everything after the country code
@@ -246,4 +247,3 @@ export const cleanupPhoneNumber = (phoneNumber) => {
     }
     return withPlus;
 };
-//# sourceMappingURL=formatter.js.map

package/dist/auth/otp.js

@@ -2,7 +2,7 @@ import { ROLES } from '@driveflux/auth/authorization/constants';
 import { config } from '@driveflux/config/backend';
 import { prisma } from '@driveflux/db';
 import { generateId } from '@driveflux/db/id';
-import { makeProblem, PROBLEM_CONFLICT, PROBLEM_INVALID_DATA, } from '@driveflux/problem';
+import { makeProblem, PROBLEM_CONFLICT, PROBLEM_INVALID_DATA } from '@driveflux/problem';
 import { Err, Ok } from '@driveflux/result';
 import { addDays } from 'date-fns/addDays';
 import { z } from 'zod';
@@ -13,43 +13,46 @@ const SendVerificationSMSBody = z.object({
     phoneNumber: z.string(),
     checkDuplication: z.boolean().optional().nullable(),
     includeUser: z.boolean().optional().nullable(),
-    userId: z.string().optional().nullable(),
+    userId: z.string().optional().nullable()
 });
-const VerifyOtpBody = z
-    .object({
-    scope: z.enum(['verify-email', 'verify-phone']),
-    email: z
-        .email()
-        .optional()
-        .transform((email) => email?.toLowerCase().trim()),
+const VerifyOtpBody = z.object({
+    scope: z.enum([
+        'verify-email',
+        'verify-phone'
+    ]),
+    email: z.email().optional().transform((email)=>email?.toLowerCase().trim()),
     phoneNumber: z.string().optional(),
-    code: z.string(),
-})
-    .refine((d) => {
+    code: z.string()
+}).refine((d)=>{
     if (d.scope === 'verify-email' && !d.email) {
         return false;
     }
     return true;
 }, {
-    path: ['email'],
-    message: 'Email is required',
-})
-    .refine((d) => {
+    path: [
+        'email'
+    ],
+    message: 'Email is required'
+}).refine((d)=>{
     if (d.scope === 'verify-phone' && !d.phoneNumber) {
         return false;
     }
     return true;
 }, {
-    path: ['phoneNumber'],
-    message: 'Phone number is required',
+    path: [
+        'phoneNumber'
+    ],
+    message: 'Phone number is required'
 });
 const INVALID_TOKEN_PROBLEM = makeProblem(PROBLEM_INVALID_DATA, 'Unable to verify token. It could have been expired.');
 const VerifyOtpOnlyBody = z.object({
     phoneNumber: z.string().optional(),
-    code: z.string(),
+    code: z.string()
 });
-export const handleVerifyOTPOnly = async ({ phoneNumber, code, }) => {
-    const tokenResult = await verifyToken(code, { scope: 'verify-phone' });
+export const handleVerifyOTPOnly = async ({ phoneNumber, code })=>{
+    const tokenResult = await verifyToken(code, {
+        scope: 'verify-phone'
+    });
     if (tokenResult.err) {
         console.error('Error verifying token', tokenResult.val);
         return new Err(INVALID_TOKEN_PROBLEM);
@@ -59,13 +62,21 @@ export const handleVerifyOTPOnly = async ({ phoneNumber, code, }) => {
     // await clearToken(tokenResult.val.id)
     return new Ok({
         phoneNumber,
-        phoneNumberVerified: true,
+        phoneNumberVerified: true
     });
 };
-export const handleVerifyOTP = async (b) => {
-    const { scope, email, phoneNumber: preFormattedPhoneNumber, code, } = VerifyOtpBody.parse(b);
+export const handleVerifyOTP = async (b)=>{
+    const { scope, email, phoneNumber: preFormattedPhoneNumber, code } = VerifyOtpBody.parse(b);
     const phoneNumber = `+${preFormattedPhoneNumber?.replace(/[^0-9]/g, '')}`;
-    const tokenResult = await verifyToken(code, { scope, metadata: { email, phoneNumber } }, { includeUser: true });
+    const tokenResult = await verifyToken(code, {
+        scope,
+        metadata: {
+            email,
+            phoneNumber
+        }
+    }, {
+        includeUser: true
+    });
     if (tokenResult.err) {
         return new Err(INVALID_TOKEN_PROBLEM);
     }
@@ -73,25 +84,25 @@ export const handleVerifyOTP = async (b) => {
         return new Err(INVALID_TOKEN_PROBLEM);
     }
     const previousUser = tokenResult.val.user;
-    const userUpdate = scope === 'verify-email'
-        ? {
-            emailVerified: true,
-            email,
-        }
-        : {
-            phoneNumberVerified: true,
-            phoneNumber,
-        };
+    const userUpdate = scope === 'verify-email' ? {
+        emailVerified: true,
+        email
+    } : {
+        phoneNumberVerified: true,
+        phoneNumber
+    };
     userUpdate.temporary = false;
     userUpdate.temporaryEmail = null;
     const userGroups = new Set(tokenResult.val.user?.groups);
     userGroups.add(ROLES.MEMBER);
-    userUpdate.groups = [...userGroups];
+    userUpdate.groups = [
+        ...userGroups
+    ];
     const user = await prisma.user.update({
         where: {
-            id: tokenResult.val.user.id,
+            id: tokenResult.val.user.id
         },
-        data: userUpdate,
+        data: userUpdate
     });
     // delete the previous token
     await clearToken(tokenResult.val.id);
@@ -101,12 +112,12 @@ export const handleVerifyOTP = async (b) => {
             id: generateId('Token'),
             user: {
                 connect: {
-                    id: user?.id,
-                },
+                    id: user?.id
+                }
             },
             expiresAt: addDays(new Date(), 365),
-            scope: 'all',
-        },
+            scope: 'all'
+        }
     });
     if (previousUser.email !== user.email) {
         await sendEmailChangedEmail(user.id);
@@ -114,21 +125,25 @@ export const handleVerifyOTP = async (b) => {
     return new Ok({
         accessToken: token.id,
         expiresAt: token.expiresAt,
-        user: user,
+        user: user
     });
 };
-export const handleSendVerificationSMS = async (b) => {
+export const handleSendVerificationSMS = async (b)=>{
     const { phoneNumber, checkDuplication, userId } = SendVerificationSMSBody.parse(b);
     const formattedPhoneNumber = `+${phoneNumber.replace(/[^0-9]/g, '')}`;
     if (checkDuplication) {
         const user = await prisma.user.findFirst({
             where: {
                 OR: [
-                    { phoneNumber: formattedPhoneNumber },
-                    { phoneNumber: phoneNumber },
+                    {
+                        phoneNumber: formattedPhoneNumber
+                    },
+                    {
+                        phoneNumber: phoneNumber
+                    }
                 ],
-                phoneNumberVerified: true,
-            },
+                phoneNumberVerified: true
+            }
         });
         if (user) {
             return new Err(makeProblem(PROBLEM_CONFLICT, 'This phone number is already registered'));
@@ -141,7 +156,7 @@ export const handleSendVerificationSMS = async (b) => {
         }
         return new Ok({
             success: true,
-            code: code.value,
+            code: code.value
         });
     }
     // Send the sms verification
@@ -149,6 +164,7 @@ export const handleSendVerificationSMS = async (b) => {
     if (verificationResult.err) {
         return verificationResult;
     }
-    return new Ok({ success: true });
+    return new Ok({
+        success: true
+    });
 };
-//# sourceMappingURL=otp.js.map

package/dist/auth/register.js

@@ -19,19 +19,25 @@ import { sendVerificationEmail } from './verifications.js';
 export const RegistrationValidation = z.object({
     firstName: z.string(),
     lastName: z.string(),
-    phoneNumber: z.string().transform((s) => s.replace(/[\s-]/g, '')),
-    authMethod: z.enum(['mobile', 'email', 'facebook', 'google', 'apple']),
+    phoneNumber: z.string().transform((s)=>s.replace(/[\s-]/g, '')),
+    authMethod: z.enum([
+        'mobile',
+        'email',
+        'facebook',
+        'google',
+        'apple'
+    ]),
     code: z.string().optional().nullable(),
     keepCode: z.boolean().optional().default(false),
-    email: z.email().transform((s) => s.toLowerCase().trim()),
-    dateOfBirth: dateValidation
-        .refine((d) => {
+    email: z.email().transform((s)=>s.toLowerCase().trim()),
+    dateOfBirth: dateValidation.refine((d)=>{
         return isAfter(d, subYears(new Date(), 25));
     }, {
-        path: ['dateOfBirth'],
-        message: 'You must be at least 25 years old to signup for the service.',
-    })
-        .optional(),
+        path: [
+            'dateOfBirth'
+        ],
+        message: 'You must be at least 25 years old to signup for the service.'
+    }).optional(),
     password: z.string().min(6).optional(),
     noMarketing: z.boolean().optional(),
     pageSource: z.string().optional().nullable(),
@@ -41,12 +47,14 @@ export const RegistrationValidation = z.object({
     userAgent: z.string().optional(),
     ipAddress: z.ipv4().or(z.ipv6()),
     sessionToken: z.string().optional(),
-    sessionId: z.string().optional(),
+    sessionId: z.string().optional()
 });
-export const handleRegister = async ({ noMarketing, password, authMethod, phoneNumber, code, keepCode, pageSource, skipPassword, fingerprint, termsVersion, userAgent, ipAddress, sessionToken, sessionId, ...body }) => {
+export const handleRegister = async ({ noMarketing, password, authMethod, phoneNumber, code, keepCode, pageSource, skipPassword, fingerprint, termsVersion, userAgent, ipAddress, sessionToken, sessionId, ...body })=>{
     let phoneNumberVerified = false;
     if (code) {
-        const tokenResult = await verifyToken(code, { scope: 'verify-phone' });
+        const tokenResult = await verifyToken(code, {
+            scope: 'verify-phone'
+        });
         if (tokenResult.err) {
             return new Err(makeProblem(PROBLEM_CONFLICT, 'Invalid OTP token'));
         }
@@ -60,7 +68,9 @@ export const handleRegister = async ({ noMarketing, password, authMethod, phoneN
     }
     // Check if the user exists
     const foundUser = await prisma.user.findFirst({
-        where: { email: body.email },
+        where: {
+            email: body.email
+        }
     });
     if (foundUser) {
         return new Err(makeProblem(PROBLEM_CONFLICT, 'A user with this email address already exists. Did you mean to login?'));
@@ -77,10 +87,12 @@ export const handleRegister = async ({ noMarketing, password, authMethod, phoneN
         preferredCurrency: 'MYR',
         preferredLocale: 'en',
         phoneNumberVerified,
-        groups: ['member'],
+        groups: [
+            'member'
+        ],
         signupParams: {
             method: authMethod,
-            source: pageSource,
+            source: pageSource
         },
         registrationComplete: true,
         accounts: {
@@ -89,16 +101,16 @@ export const handleRegister = async ({ noMarketing, password, authMethod, phoneN
                 object: 'account',
                 type: 'default',
                 provider: 'credentials',
-                providerAccountId: id,
-            },
+                providerAccountId: id
+            }
         },
         tokens: {
             create: {
                 id: tokenId,
                 expiresAt: addDays(new Date(), 365),
-                scope: 'all',
-            },
-        },
+                scope: 'all'
+            }
+        }
     };
     const { user: _removeDueToNestedCreate, ...consentCreate } = getConsentCreateData({
         user: userCreateData,
@@ -107,28 +119,28 @@ export const handleRegister = async ({ noMarketing, password, authMethod, phoneN
         ipAddress: ipAddress,
         userAgent: userAgent,
         sessionToken: tokenId,
-        consentType: 'terms',
+        consentType: 'terms'
     });
     const finalCreateData = {
         ...userCreateData,
         consents: {
-            create: consentCreate,
-        },
+            create: consentCreate
+        }
     };
     // Find a host with the same email
     const host = await prisma.host.findFirst({
         where: {
-            email: finalCreateData.email,
+            email: finalCreateData.email
         },
         select: {
-            id: true,
-        },
+            id: true
+        }
     });
     if (host?.id) {
         finalCreateData.host = {
             connect: {
-                id: host.id,
-            },
+                id: host.id
+            }
         };
     }
     const user = await prisma.user.create({
@@ -136,20 +148,21 @@ export const handleRegister = async ({ noMarketing, password, authMethod, phoneN
         include: {
             tokens: {
                 where: {
-                    id: tokenId,
-                },
-            },
-        },
+                    id: tokenId
+                }
+            }
+        }
     });
     // We don't want this to be a task. It should be instant
     await sendVerificationEmail(user.id);
     if (!noMarketing) {
-        await setContactInList(user.id, { generalMarketing: true });
+        await setContactInList(user.id, {
+            generalMarketing: true
+        });
     }
     await refreshEmailPreferences(user.id);
     return new Ok({
         token: user.tokens[0],
-        user,
+        user
     });
 };
-//# sourceMappingURL=register.js.map