@driveflux/api-functions 1.0.71 → 1.0.72

package/dist/auth/confirm.js

@@ -11,30 +11,34 @@ 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,
@@ -43,41 +47,42 @@ 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,11 +40,12 @@ 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,9 +232,8 @@ 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
@@ -247,3 +246,4 @@ 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,46 +13,43 @@ 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);
@@ -62,21 +59,13 @@ 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);
     }
@@ -84,25 +73,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);
@@ -112,12 +101,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);
@@ -125,25 +114,21 @@ 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'));
@@ -156,7 +141,7 @@ export const handleSendVerificationSMS = async (b)=>{
         }
         return new Ok({
             success: true,
-            code: code.value
+            code: code.value,
         });
     }
     // Send the sms verification
@@ -164,7 +149,6 @@ 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,37 +18,32 @@ 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'));
         }
@@ -62,9 +57,7 @@ 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?'));
@@ -82,20 +75,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: {
@@ -104,33 +97,32 @@ 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

package/dist/auth/tokens.d.ts

@@ -13,8 +13,8 @@ export declare const createToken: (userId: string | null, type: "email" | "phone
     metadata: PrismaJson.AnyMetadata | null;
     createdAt: Date;
     updatedAt: Date;
-    userId: string | null;
     value: string | null;
+    userId: string | null;
     client: string | null;
     identifier: string | null;
     expiresAt: Date | null;
@@ -29,8 +29,8 @@ export declare const createEmailToken: (userId: string, email: string) => Promis
     metadata: PrismaJson.AnyMetadata | null;
     createdAt: Date;
     updatedAt: Date;
-    userId: string | null;
     value: string | null;
+    userId: string | null;
     client: string | null;
     identifier: string | null;
     expiresAt: Date | null;
@@ -45,8 +45,8 @@ export declare const createSMSToken: (userId: string | null, phoneNumber: string
     metadata: PrismaJson.AnyMetadata | null;
     createdAt: Date;
     updatedAt: Date;
-    userId: string | null;
     value: string | null;
+    userId: string | null;
     client: string | null;
     identifier: string | null;
     expiresAt: Date | null;