@driveflux/api-functions 0.0.3 → 0.0.4

package/dist/auth/formatter.js

@@ -1,4 +1,4 @@
-var knownCountryCodes = [
+const knownCountryCodes = [
     '1',
     '376',
     '93',
@@ -221,20 +221,19 @@ var knownCountryCodes = [
     '246',
     '269',
     '692',
-    '383'
+    '383',
 ];
-export var cleanupPhoneNumber = function(phoneNumber) {
+export const cleanupPhoneNumber = (phoneNumber) => {
     // Remove all characters except numbers and +
-    var cleaned = phoneNumber.replace(/[^\d+]/g, '');
+    const cleaned = phoneNumber.replace(/[^\d+]/g, '');
     // If it doesn't start with +, add it
-    var withPlus = cleaned.startsWith('+') ? cleaned : "+".concat(cleaned);
+    const withPlus = cleaned.startsWith('+') ? cleaned : `+${cleaned}`;
     // Find the country code by checking against known codes
-    var countryCode = '';
-    var remainingNumber = '';
+    let countryCode = '';
+    let remainingNumber = '';
     // Try to find the country code by checking the longest matches first
-    for(var i = 4; i >= 1; i--){
-        var 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
@@ -243,7 +242,8 @@ export var cleanupPhoneNumber = function(phoneNumber) {
     }
     // If we found a country code and the remaining number starts with 0, remove it
     if (countryCode && remainingNumber.startsWith('0')) {
-        return "+".concat(countryCode).concat(remainingNumber.substring(1));
+        return `+${countryCode}${remainingNumber.substring(1)}`;
     }
     return withPlus;
 };
+//# sourceMappingURL=formatter.js.map

package/dist/auth/otp.js

@@ -1,424 +1,154 @@
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _async_to_generator(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-function _ts_generator(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
-        return this;
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-}
 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';
 import { sendEmailChangedEmail } from './emails.js';
 import { clearToken, createSMSToken, verifyToken } from './tokens.js';
 import { sendVerificationSMS } from './verifications.js';
-var SendVerificationSMSBody = z.object({
+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(),
 });
-var VerifyOtpBody = z.object({
-    scope: z.enum([
-        'verify-email',
-        'verify-phone'
-    ]),
-    email: z.email().optional().transform(function(email) {
-        return email === null || email === void 0 ? void 0 : 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(function(d) {
+    code: z.string(),
+})
+    .refine((d) => {
     if (d.scope === 'verify-email' && !d.email) {
         return false;
     }
     return true;
 }, {
-    path: [
-        'email'
-    ],
-    message: 'Email is required'
-}).refine(function(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',
 });
-var INVALID_TOKEN_PROBLEM = makeProblem(PROBLEM_INVALID_DATA, 'Unable to verify token. It could have been expired.');
-var VerifyOtpOnlyBody = z.object({
+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 var handleVerifyOTPOnly = function(param) {
-    var phoneNumber = param.phoneNumber, code = param.code;
-    return _async_to_generator(function() {
-        var tokenResult;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    return [
-                        4,
-                        verifyToken(code, {
-                            scope: 'verify-phone'
-                        })
-                    ];
-                case 1:
-                    tokenResult = _state.sent();
-                    if (tokenResult.err) {
-                        console.log('Error verifying token', tokenResult.val);
-                        return [
-                            2,
-                            new Err(INVALID_TOKEN_PROBLEM)
-                        ];
-                    }
-                    // delete the previous token
-                    // TODO maybe: verify this token when registering one more time then clear it
-                    // await clearToken(tokenResult.val.id)
-                    return [
-                        2,
-                        new Ok({
-                            phoneNumber: phoneNumber,
-                            phoneNumberVerified: true
-                        })
-                    ];
-            }
-        });
-    })();
+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);
+    }
+    // delete the previous token
+    // TODO maybe: verify this token when registering one more time then clear it
+    // await clearToken(tokenResult.val.id)
+    return new Ok({
+        phoneNumber,
+        phoneNumberVerified: true,
+    });
 };
-export var handleVerifyOTP = function(b) {
-    return _async_to_generator(function() {
-        var _tokenResult_val_user, _VerifyOtpBody_parse, scope, email, preFormattedPhoneNumber, code, phoneNumber, tokenResult, previousUser, userUpdate, userGroups, user, token;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    _VerifyOtpBody_parse = VerifyOtpBody.parse(b), scope = _VerifyOtpBody_parse.scope, email = _VerifyOtpBody_parse.email, preFormattedPhoneNumber = _VerifyOtpBody_parse.phoneNumber, code = _VerifyOtpBody_parse.code;
-                    phoneNumber = "+".concat(preFormattedPhoneNumber === null || preFormattedPhoneNumber === void 0 ? void 0 : preFormattedPhoneNumber.replace(/[^0-9]/g, ''));
-                    return [
-                        4,
-                        verifyToken(code, {
-                            scope: scope,
-                            metadata: {
-                                email: email,
-                                phoneNumber: phoneNumber
-                            }
-                        }, {
-                            includeUser: true
-                        })
-                    ];
-                case 1:
-                    tokenResult = _state.sent();
-                    if (tokenResult.err) {
-                        return [
-                            2,
-                            new Err(INVALID_TOKEN_PROBLEM)
-                        ];
-                    }
-                    if (!tokenResult.val.user) {
-                        return [
-                            2,
-                            new Err(INVALID_TOKEN_PROBLEM)
-                        ];
-                    }
-                    previousUser = tokenResult.val.user;
-                    userUpdate = scope === 'verify-email' ? {
-                        emailVerified: true,
-                        email: email
-                    } : {
-                        phoneNumberVerified: true,
-                        phoneNumber: phoneNumber
-                    };
-                    userUpdate.temporary = false;
-                    userUpdate.temporaryEmail = null;
-                    userGroups = new Set((_tokenResult_val_user = tokenResult.val.user) === null || _tokenResult_val_user === void 0 ? void 0 : _tokenResult_val_user.groups);
-                    userGroups.add(ROLES.MEMBER);
-                    userUpdate.groups = _to_consumable_array(userGroups);
-                    return [
-                        4,
-                        prisma.user.update({
-                            where: {
-                                id: tokenResult.val.user.id
-                            },
-                            data: userUpdate
-                        })
-                    ];
-                case 2:
-                    user = _state.sent();
-                    // delete the previous token
-                    return [
-                        4,
-                        clearToken(tokenResult.val.id)
-                    ];
-                case 3:
-                    _state.sent();
-                    return [
-                        4,
-                        prisma.token.create({
-                            data: {
-                                id: generateId('Token'),
-                                user: {
-                                    connect: {
-                                        id: user === null || user === void 0 ? void 0 : user.id
-                                    }
-                                },
-                                expiresAt: addDays(new Date(), 365),
-                                scope: 'all'
-                            }
-                        })
-                    ];
-                case 4:
-                    token = _state.sent();
-                    if (!(previousUser.email !== user.email)) return [
-                        3,
-                        6
-                    ];
-                    return [
-                        4,
-                        sendEmailChangedEmail(user.id)
-                    ];
-                case 5:
-                    _state.sent();
-                    _state.label = 6;
-                case 6:
-                    return [
-                        2,
-                        new Ok({
-                            accessToken: token.id,
-                            expiresAt: token.expiresAt,
-                            user: user
-                        })
-                    ];
-            }
-        });
-    })();
+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 });
+    if (tokenResult.err) {
+        return new Err(INVALID_TOKEN_PROBLEM);
+    }
+    if (!tokenResult.val.user) {
+        return new Err(INVALID_TOKEN_PROBLEM);
+    }
+    const previousUser = tokenResult.val.user;
+    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];
+    const user = await prisma.user.update({
+        where: {
+            id: tokenResult.val.user.id,
+        },
+        data: userUpdate,
+    });
+    // delete the previous token
+    await clearToken(tokenResult.val.id);
+    // Login the user
+    const token = await prisma.token.create({
+        data: {
+            id: generateId('Token'),
+            user: {
+                connect: {
+                    id: user?.id,
+                },
+            },
+            expiresAt: addDays(new Date(), 365),
+            scope: 'all',
+        },
+    });
+    if (previousUser.email !== user.email) {
+        await sendEmailChangedEmail(user.id);
+    }
+    return new Ok({
+        accessToken: token.id,
+        expiresAt: token.expiresAt,
+        user: user,
+    });
 };
-export var handleSendVerificationSMS = function(b) {
-    return _async_to_generator(function() {
-        var _SendVerificationSMSBody_parse, phoneNumber, checkDuplication, userId, formattedPhoneNumber, user, code, verificationResult;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    _SendVerificationSMSBody_parse = SendVerificationSMSBody.parse(b), phoneNumber = _SendVerificationSMSBody_parse.phoneNumber, checkDuplication = _SendVerificationSMSBody_parse.checkDuplication, userId = _SendVerificationSMSBody_parse.userId;
-                    formattedPhoneNumber = "+".concat(phoneNumber.replace(/[^0-9]/g, ''));
-                    if (!checkDuplication) return [
-                        3,
-                        2
-                    ];
-                    return [
-                        4,
-                        prisma.user.findFirst({
-                            where: {
-                                OR: [
-                                    {
-                                        phoneNumber: formattedPhoneNumber
-                                    },
-                                    {
-                                        phoneNumber: phoneNumber
-                                    }
-                                ],
-                                phoneNumberVerified: true
-                            }
-                        })
-                    ];
-                case 1:
-                    user = _state.sent();
-                    if (user) {
-                        return [
-                            2,
-                            new Err(makeProblem(PROBLEM_CONFLICT, 'This phone number is already registered'))
-                        ];
-                    }
-                    _state.label = 2;
-                case 2:
-                    if (!(!config.isProd && !config.sendSMSOutsideOfProd)) return [
-                        3,
-                        4
-                    ];
-                    return [
-                        4,
-                        createSMSToken(userId || null, formattedPhoneNumber)
-                    ];
-                case 3:
-                    code = _state.sent();
-                    if (!(code === null || code === void 0 ? void 0 : code.value)) {
-                        return [
-                            2,
-                            new Err(makeProblem(PROBLEM_INVALID_DATA, 'Invalid Data'))
-                        ];
-                    }
-                    return [
-                        2,
-                        new Ok({
-                            success: true,
-                            code: code.value
-                        })
-                    ];
-                case 4:
-                    return [
-                        4,
-                        sendVerificationSMS(userId || null, phoneNumber)
-                    ];
-                case 5:
-                    verificationResult = _state.sent();
-                    if (verificationResult.err) {
-                        return [
-                            2,
-                            verificationResult
-                        ];
-                    }
-                    return [
-                        2,
-                        new Ok({
-                            success: true
-                        })
-                    ];
-            }
+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 },
+                ],
+                phoneNumberVerified: true,
+            },
         });
-    })();
+        if (user) {
+            return new Err(makeProblem(PROBLEM_CONFLICT, 'This phone number is already registered'));
+        }
+    }
+    if (!config.isProd && !config.sendSMSOutsideOfProd) {
+        const code = await createSMSToken(userId || null, formattedPhoneNumber);
+        if (!code?.value) {
+            return new Err(makeProblem(PROBLEM_INVALID_DATA, 'Invalid Data'));
+        }
+        return new Ok({
+            success: true,
+            code: code.value,
+        });
+    }
+    // Send the sms verification
+    const verificationResult = await sendVerificationSMS(userId || null, phoneNumber);
+    if (verificationResult.err) {
+        return verificationResult;
+    }
+    return new Ok({ success: true });
 };
+//# sourceMappingURL=otp.js.map

package/dist/auth/register.d.ts

@@ -20,7 +20,7 @@ declare const Body: z.ZodObject<{
     code: z.ZodNullable<z.ZodOptional<z.ZodString>>;
     keepCode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     email: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    dateOfBirth: z.ZodOptional<z.ZodDate>;
+    dateOfBirth: z.ZodOptional<z.ZodCodec<z.ZodISODateTime, z.ZodDate>>;
     password: z.ZodOptional<z.ZodString>;
     noMarketing: z.ZodOptional<z.ZodBoolean>;
     pageSource: z.ZodNullable<z.ZodOptional<z.ZodString>>;