@driveflux/api-functions 1.0.111 → 1.0.113

package/dist/auth/confirm.js

@@ -13,34 +13,35 @@ 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,
@@ -48,20 +49,18 @@ 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: {
@@ -70,30 +69,31 @@ 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,53 +1,58 @@
 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,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.d.ts

@@ -21,8 +21,8 @@ declare const SendVerificationSMSBody: z.ZodObject<{
 }, z.core.$strip>;
 declare const VerifyOtpBody: z.ZodObject<{
     scope: z.ZodEnum<{
-        "verify-phone": "verify-phone";
         "verify-email": "verify-email";
+        "verify-phone": "verify-phone";
     }>;
     email: z.ZodPipe<z.ZodOptional<z.ZodEmail>, z.ZodTransform<string | undefined, string | undefined>>;
     phoneNumber: z.ZodOptional<z.ZodString>;

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.error('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.d.ts

@@ -11,8 +11,8 @@ export declare const RegistrationValidation: z.ZodObject<{
     lastName: z.ZodString;
     phoneNumber: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     authMethod: z.ZodEnum<{
-        mobile: "mobile";
         email: "email";
+        mobile: "mobile";
         facebook: "facebook";
         google: "google";
         apple: "apple";

package/dist/auth/register.js

@@ -19,25 +19,19 @@ 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(),
@@ -47,14 +41,12 @@ 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'));
         }
@@ -68,9 +60,7 @@ 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?'));
@@ -87,12 +77,10 @@ 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: {
@@ -101,16 +89,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,
@@ -119,28 +107,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({
@@ -148,21 +136,20 @@ 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