@driveflux/api-functions 1.0.72 → 1.0.75

package/dist/auth/confirm.js

@@ -11,34 +11,30 @@ import { sendVerificationEmail } from './verifications.js';
 const Body = z.object({
     firstName: z.string(),
     lastName: 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(),
-    email: z
-        .string()
-        .email()
-        .transform((s) => s.toLowerCase().trim()),
-    pageSource: z.string().optional().nullable(),
+    email: z.string().email().transform((s)=>s.toLowerCase().trim()),
+    pageSource: z.string().optional().nullable()
 });
-export const handleConfirmUser = async (b, user, xForwardedFor) => {
+export const handleConfirmUser = async (b, user, xForwardedFor)=>{
     const { phoneNumber, email, code, pageSource, ...body } = Body.parse(b);
     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 updatedUser = await prisma.user.update({
         where: {
-            id: user.id,
+            id: user.id
         },
         data: {
             ...body,
@@ -47,42 +43,41 @@ export const handleConfirmUser = async (b, user, xForwardedFor) => {
             preferredLocale: 'en',
             phoneNumberVerified,
             consented: true,
-            groups: ['member'],
+            groups: [
+                'member'
+            ],
             signupParams: {
                 method,
-                source: pageSource,
+                source: pageSource
             },
             consents: {
                 create: {
                     id: generateId('UserConsent'),
-                    ipAddress: Array.isArray(xForwardedFor)
-                        ? xForwardedFor?.[0] || '0.0.0.0'
-                        : xForwardedFor || '0.0.0.0',
+                    ipAddress: Array.isArray(xForwardedFor) ? xForwardedFor?.[0] || '0.0.0.0' : xForwardedFor || '0.0.0.0',
                     consentType: 'terms',
-                    email: email,
-                },
+                    email: email
+                }
             },
-            registrationComplete: true,
-        },
+            registrationComplete: true
+        }
     });
     const token = await prisma.token.create({
         data: {
             id: generateId('Token'),
             user: {
                 connect: {
-                    id: updatedUser.id,
-                },
+                    id: updatedUser.id
+                }
             },
             expiresAt: addDays(new Date(), 365),
-            scope: 'all',
-        },
+            scope: 'all'
+        }
     });
     // 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,
-        user: updatedUser,
+        user: updatedUser
     });
 };
-//# sourceMappingURL=confirm.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.log('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

@@ -18,32 +18,37 @@ import { sendVerificationEmail } from './verifications.js';
 const Body = 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
-        .string()
-        .email()
-        .transform((s) => s.toLowerCase().trim()),
-    dateOfBirth: dateValidation
-        .refine((d) => {
+    email: z.string().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(),
-    skipPassword: z.boolean().optional().nullable(),
+    skipPassword: z.boolean().optional().nullable()
 });
-export const handleRegister = async (b, xForwardedFor) => {
+export const handleRegister = async (b, xForwardedFor)=>{
     const { noMarketing, password, authMethod, phoneNumber, code, keepCode, pageSource, skipPassword, ...body } = Body.parse(b);
     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'));
         }
@@ -57,7 +62,9 @@ export const handleRegister = async (b, xForwardedFor) => {
     }
     // 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?'));
@@ -75,20 +82,20 @@ export const handleRegister = async (b, xForwardedFor) => {
             preferredLocale: 'en',
             phoneNumberVerified,
             consented: true,
-            groups: ['member'],
+            groups: [
+                'member'
+            ],
             consents: {
                 create: {
                     id: generateId('UserConsent'),
-                    ipAddress: Array.isArray(xForwardedFor)
-                        ? xForwardedFor?.[0] || '0.0.0.0'
-                        : xForwardedFor || '0.0.0.0',
+                    ipAddress: Array.isArray(xForwardedFor) ? xForwardedFor?.[0] || '0.0.0.0' : xForwardedFor || '0.0.0.0',
                     consentType: 'terms',
-                    email: body.email,
-                },
+                    email: body.email
+                }
             },
             signupParams: {
                 method: authMethod,
-                source: pageSource,
+                source: pageSource
             },
             registrationComplete: true,
             accounts: {
@@ -97,32 +104,33 @@ export const handleRegister = async (b, xForwardedFor) => {
                     object: 'account',
                     type: 'default',
                     provider: 'credentials',
-                    providerAccountId: id,
-                },
-            },
-        },
+                    providerAccountId: id
+                }
+            }
+        }
     });
     const token = await prisma.token.create({
         data: {
             id: generateId('Token'),
             user: {
                 connect: {
-                    id: user.id,
-                },
+                    id: user.id
+                }
             },
             expiresAt: addDays(new Date(), 365),
-            scope: 'all',
-        },
+            scope: 'all'
+        }
     });
     // 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,
+        user
     });
 };
-//# sourceMappingURL=register.js.map