@driveflux/api-functions 0.0.7-next.18 → 0.0.7-next.2

package/dist/auth/formatter.js

@@ -1,4 +1,4 @@
-const knownCountryCodes = [
+var knownCountryCodes = [
     '1',
     '376',
     '93',
@@ -223,17 +223,17 @@ const knownCountryCodes = [
     '692',
     '383'
 ];
-export const cleanupPhoneNumber = (phoneNumber)=>{
+export var cleanupPhoneNumber = function(phoneNumber) {
     // Remove all characters except numbers and +
-    const cleaned = phoneNumber.replace(/[^\d+]/g, '');
+    var cleaned = phoneNumber.replace(/[^\d+]/g, '');
     // If it doesn't start with +, add it
-    const withPlus = cleaned.startsWith('+') ? cleaned : `+${cleaned}`;
+    var withPlus = cleaned.startsWith('+') ? cleaned : "+".concat(cleaned);
     // Find the country code by checking against known codes
-    let countryCode = '';
-    let remainingNumber = '';
+    var countryCode = '';
+    var 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(var i = 4; i >= 1; i--){
+        var potentialCode = withPlus.substring(1, 1 + i) // Skip the + and take i digits
         ;
         if (knownCountryCodes.includes(potentialCode)) {
             countryCode = potentialCode;
@@ -243,7 +243,7 @@ export const cleanupPhoneNumber = (phoneNumber)=>{
     }
     // If we found a country code and the remaining number starts with 0, remove it
     if (countryCode && remainingNumber.startsWith('0')) {
-        return `+${countryCode}${remainingNumber.substring(1)}`;
+        return "+".concat(countryCode).concat(remainingNumber.substring(1));
     }
     return withPlus;
 };

package/dist/auth/otp.js

@@ -1,3 +1,148 @@
+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';
@@ -9,21 +154,23 @@ import { z } from 'zod';
 import { sendEmailChangedEmail } from './emails.js';
 import { clearToken, createSMSToken, verifyToken } from './tokens.js';
 import { sendVerificationSMS } from './verifications.js';
-const SendVerificationSMSBody = z.object({
+var SendVerificationSMSBody = z.object({
     phoneNumber: z.string(),
     checkDuplication: z.boolean().optional().nullable(),
     includeUser: z.boolean().optional().nullable(),
     userId: z.string().optional().nullable()
 });
-const VerifyOtpBody = z.object({
+var VerifyOtpBody = z.object({
     scope: z.enum([
         'verify-email',
         'verify-phone'
     ]),
-    email: z.email().optional().transform((email)=>email?.toLowerCase().trim()),
+    email: z.email().optional().transform(function(email) {
+        return email === null || email === void 0 ? void 0 : email.toLowerCase().trim();
+    }),
     phoneNumber: z.string().optional(),
     code: z.string()
-}).refine((d)=>{
+}).refine(function(d) {
     if (d.scope === 'verify-email' && !d.email) {
         return false;
     }
@@ -33,7 +180,7 @@ const VerifyOtpBody = z.object({
         'email'
     ],
     message: 'Email is required'
-}).refine((d)=>{
+}).refine(function(d) {
     if (d.scope === 'verify-phone' && !d.phoneNumber) {
         return false;
     }
@@ -44,127 +191,234 @@ const VerifyOtpBody = z.object({
     ],
     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({
+var INVALID_TOKEN_PROBLEM = makeProblem(PROBLEM_INVALID_DATA, 'Unable to verify token. It could have been expired.');
+var VerifyOtpOnlyBody = z.object({
     phoneNumber: z.string().optional(),
     code: z.string()
 });
-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 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 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 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
+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)
+                        ];
                     }
-                ],
-                phoneNumberVerified: true
+                    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
+                        })
+                    ];
             }
         });
-        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
+    })();
+};
+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
+                        })
+                    ];
+            }
         });
-    }
-    // Send the sms verification
-    const verificationResult = await sendVerificationSMS(userId || null, phoneNumber);
-    if (verificationResult.err) {
-        return verificationResult;
-    }
-    return new Ok({
-        success: true
-    });
+    })();
 };