@edgedev/firebase 1.9.17 → 1.9.19

package/edgeFirebase.ts

@@ -47,10 +47,13 @@ import {
   browserPopupRedirectResolver,
   signInWithPopup,
   signInWithPhoneNumber,
+  sendSignInLinkToEmail,
   updateEmail,
   RecaptchaVerifier,
   ConfirmationResult,
   PhoneAuthProvider,
+  signInWithCustomToken,
+  updateProfile,
 } from "firebase/auth";
 
 import { getFunctions, httpsCallable, connectFunctionsEmulator } from "firebase/functions";
@@ -89,7 +92,7 @@ interface permissions {
 
 type action = "assign" | "read" | "write" | "delete";
 
-type authProviders = "email" | "microsoft" | "google" | "facebook" | "github" | "twitter" | "apple" | "phone";
+type authProviders = "email" | "microsoft" | "google" | "facebook" | "github" | "twitter" | "apple" | "phone" | "emailLink" | "customToken";
 
 interface role {
   collectionPath: "-" | string; // - is root
@@ -133,8 +136,10 @@ interface newUser {
 interface userRegister {
   uid?: string;
   email?: string;
+  token?: string;
+  identifier?: string;
   phoneCode?: string;
-  confirmationResult?: ConfirmationResult;
+  phoneNumber?: string;
   password?: string;
   meta: object;
   registrationCode: string;
@@ -441,19 +446,15 @@ export const EdgeFirebase = class {
     });
   };
 
-  public logInWithPhone = async (confirmationResult: ConfirmationResult, phoneCode: string): Promise<void> => {
-    const oldDiv = document.getElementById("recaptcha-container");
-    if (oldDiv) oldDiv.remove();
+  public loginWithCustomToken = async (token: string): Promise<void> => {
     try {
-      console.log(confirmationResult)
-      const result = await confirmationResult.confirm(phoneCode);
+      const result = await signInWithCustomToken(this.auth, token);
       if (!Object.prototype.hasOwnProperty.call(result, "user")) {
         this.user.logInError = true;
         this.user.logInErrorMessage = JSON.stringify(result)
         this.logOut();
         return;
       }
-      console.log(result.user.uid);
       const userRef = doc(this.db, "users", result.user.uid);
       const userSnap = await getDoc(userRef);
       if (!userSnap.exists()) { 
@@ -468,6 +469,39 @@ export const EdgeFirebase = class {
       this.logOut();
       return;
     }
+  }
+
+  public logInWithPhone = async (phoneNumber: string, phoneCode: string): Promise<void> => {
+    try {
+      const verifyCode: any = await this.runFunction("verifyPhoneNumber", {phone: phoneNumber, code: phoneCode});
+      if (verifyCode.data.success) {
+        const result = await signInWithCustomToken(this.auth, verifyCode.data.token);
+        if (!Object.prototype.hasOwnProperty.call(result, "user")) {
+          this.user.logInError = true;
+          this.user.logInErrorMessage = JSON.stringify(result)
+          this.logOut();
+          return;
+        }
+        const userRef = doc(this.db, "users", result.user.uid);
+        const userSnap = await getDoc(userRef);
+        if (!userSnap.exists()) { 
+          this.user.logInError = true;
+          this.user.logInErrorMessage = "User does not exist";
+          this.logOut();
+          return;
+        }
+      } else {
+        this.user.logInError = true;
+        this.user.logInErrorMessage = verifyCode.data.error;
+        this.logOut();
+        return;
+      }
+    } catch (error) {
+      this.user.logInError = true;
+      this.user.logInErrorMessage = error.message;
+      this.logOut();
+      return;
+    }
   };
 
   public logInWithMicrosoft = async (providerScopes: string[] = []): Promise<void> => {
@@ -535,24 +569,37 @@ export const EdgeFirebase = class {
     }
   }
 
-  public sendPhoneCode = async (phone: string): Promise<any> => {
-    const oldDiv = document.getElementById("recaptcha-container");
-    if (oldDiv) oldDiv.remove();
-
-    const newDiv = document.createElement("div");
-    newDiv.setAttribute("id", "recaptcha-container");
-    document.body.appendChild(newDiv);
-
-    const recaptchaVerifier = new RecaptchaVerifier("recaptcha-container", {
-      'size': 'invisible',
-      'callback': (response) => {
-        console.log(response)
-      }
-    }, this.auth);
+  public sendEmailLink = async (email: string): Promise<any> => {
+    const actionCodeSettings = {
+      url: window.location.href,
+      handleCodeInApp: true,
+    };
+    try {
+      await sendSignInLinkToEmail(this.auth, email, actionCodeSettings);
+      return true;
+    } catch (error) {
+      this.user.logInError = true;
+      this.user.logInErrorMessage = error.message;
+      this.logOut();
+      return false;
+    }
+  };
 
+  public sendPhoneCode = async (phone: string): Promise<any> => {
     try {
-      const confirmationResult = await signInWithPhoneNumber(this.auth, phone, recaptchaVerifier);
-      return confirmationResult 
+      const callable = httpsCallable(this.functions, "sendVerificationCode");
+      const result: any = await callable({phone: phone});
+
+      if (result.data.success !== false) {
+        console.log('good')
+        return result.data;
+      } else  {
+        console.log('bad')
+        this.user.logInError = true;
+        this.user.logInErrorMessage = result.data.error;
+        this.logOut();
+        return false;
+      }
     } catch (error) {
       this.user.logInError = true;
       this.user.logInErrorMessage = error.message;
@@ -608,17 +655,50 @@ export const EdgeFirebase = class {
           }
         } else if (authProvider === "microsoft") {
          response = await this.registerUserWithMicrosoft(providerScopes);
+        } else if (authProvider === "customToken") {
+          if (!Object.prototype.hasOwnProperty.call(userRegister, 'token')) {
+            return this.sendResponse({
+              success: false,
+              message: "Token is required for registration when authProvider is customToken.",
+              meta: {}
+            });
+          }
+          if (!Object.prototype.hasOwnProperty.call(userRegister, 'identifier')) {
+            return this.sendResponse({
+              success: false,
+              message: "Identifier is required for registration when authProvider is customToken.",
+              meta: {}
+            });
+          }
+          try {
+            response = await signInWithCustomToken(this.auth, userRegister.token);
+            await updateProfile(response.user, {
+              displayName: userRegister.identifier
+            });
+          } catch (error) {
+            response = error;
+          }
         } else if (authProvider === "phone") {
-          const oldDiv = document.getElementById("recaptcha-container");
-          if (oldDiv) oldDiv.remove();
           try {
-            response = await userRegister.confirmationResult.confirm(userRegister.phoneCode);
+            const verifyCode: any = await this.runFunction("verifyPhoneNumber", {phone: userRegister.phoneNumber, code: userRegister.phoneCode});
+            if (verifyCode.data.success) {
+              response = await signInWithCustomToken(this.auth, verifyCode.data.token);
+              await updateProfile(response.user, {
+                displayName: userRegister.phoneNumber
+              });
+            } else {
+              return this.sendResponse({
+                success: false,
+                message: verifyCode.data.error,
+                meta: {}
+              });
+            }
           } catch (error) {
             // Handle the case where the code is incorrect or expired
             response = error;
           }
-              
-        
+        } else if (authProvider === "emailLink") {
+          // TOOD: emailLink stuff
         }
         if (!Object.prototype.hasOwnProperty.call(response, "user")) { 
           return this.sendResponse({
@@ -627,14 +707,13 @@ export const EdgeFirebase = class {
             meta: {}
           });
         }
-
+        
         let metaUpdate = {};
         if (Object.prototype.hasOwnProperty.call(userRegister, 'meta')) {
           metaUpdate = userRegister.meta;
         }else{
           metaUpdate = user.meta;
         }
-
         let stagedUserUpdate: {userId?: string, templateUserId?: string, dynamicDocumentFieldValue?: string, uid: string, meta: unknown, templateMeta?: unknown} = {userId: response.user.uid, uid: response.user.uid, meta: metaUpdate}
         if (user.isTemplate) {
           stagedUserUpdate = {templateUserId: response.user.uid, uid: response.user.uid, meta: user.meta, templateMeta: metaUpdate}
@@ -1391,28 +1470,52 @@ export const EdgeFirebase = class {
     collectionPath: string,
     docId: string
   ): Promise<actionResponse> => {
-    // console.log(collectionPath)
-    // console.log(docId)
     const canRead = await this.permissionCheck("read", collectionPath + '/' + docId);
     this.data[collectionPath + '/' + docId] = {};
     this.stopSnapshot(collectionPath + '/' + docId);
     this.unsubscibe[collectionPath + '/' + docId] = null;
     if (canRead) {
       const docRef = doc(this.db, collectionPath, docId);
-      const unsubscribe = onSnapshot(docRef, (doc) => {
-        if (doc.exists()) {
-          const item = doc.data();
-          item.docId = doc.id;
-          this.data[collectionPath + '/' + docId] = item;
-        } else {
-          this.data[collectionPath + '/' + docId] = {};
-        }
-      });
-      this.unsubscibe[collectionPath + '/' + docId] = unsubscribe;
-      return this.sendResponse({
-        success: true,
-        message: "line 1336",
-        meta: {}
+      
+      return new Promise<actionResponse>((resolve, reject) => {
+        let firstRun = true;
+        const unsubscribe = onSnapshot(docRef, (doc) => {
+          if (doc.exists()) {
+            const item = doc.data();
+            item.docId = doc.id;
+            this.data[collectionPath + '/' + docId] = item;
+
+            // Only resolve the Promise on first run of onSnapshot if document exists
+            if(firstRun) {
+              firstRun = false;
+              resolve(this.sendResponse({
+                success: true,
+                message: "startDocumentSnapshot " + collectionPath + '/' + docId,
+                meta: {}
+              }));
+            }
+          } else {
+            this.data[collectionPath + '/' + docId] = {};
+
+            // Resolve the Promise with failure response if no document exists
+            if(firstRun) {
+              firstRun = false;
+              resolve(this.sendResponse({
+                success: false,
+                message: `No document found in "${collectionPath}/${docId}"`,
+                meta: {}
+              }));
+            }
+          }
+        }, (error) => {
+          // Reject the Promise with the error response
+          reject(this.sendResponse({
+            success: false,
+            message: `Error fetching document from "${collectionPath}/${docId}": ${error.message}`,
+            meta: {}
+          }));
+        });
+        this.unsubscibe[collectionPath + '/' + docId] = unsubscribe;
       });
     } else {
       return this.sendResponse({
@@ -1423,6 +1526,7 @@ export const EdgeFirebase = class {
     }
   };
 
+
   public startSnapshot = async (
     collectionPath: string,
     queryList: FirestoreQuery[] = [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgedev/firebase",
-  "version": "1.9.17",
+  "version": "1.9.19",
   "description": "Vue 3 / Nuxt 3 Plugin or Nuxt 3 plugin for firebase authentication and firestore.",
   "main": "index.ts",
   "scripts": {

package/src/functions.js

@@ -1,5 +1,87 @@
 // START @edge/firebase functions
 
+const twilio = require('twilio')
+const authToken = functions.config().twilio.auth_token
+const accountSid = functions.config().twilio.sid
+const systemNumber = functions.config().twilio.system_number
+
+function formatPhoneNumber(phone) {
+  // Remove non-numeric characters from the phone number
+  const numericPhone = phone.replace(/\D/g, '')
+  // Return the formatted number
+  return `+1${numericPhone}`
+}
+
+exports.sendVerificationCode = functions.https.onCall(async (data, context) => {
+  const code = (Math.floor(Math.random() * 1000000) + 1000000).toString().substring(1)
+  const phone = formatPhoneNumber(data.phone)
+
+  try {
+    const client = twilio(accountSid, authToken)
+    await client.messages.create({
+      body: `Your verification code is: ${code}`,
+      to: phone, // the user's phone number
+      from: systemNumber, // your Twilio phone number from the configuration
+    })
+  }
+  catch (error) {
+    console.log(error)
+    return { success: false, error: 'Invalid Phone #' }
+  }
+
+  try {
+    // Use the formatted phone number as the document ID for Firestore
+    await db.collection('phone-auth').doc(phone).set({
+      phone,
+      code,
+    })
+    return phone
+  }
+  catch (error) {
+    return { success: false, error }
+  }
+})
+
+exports.verifyPhoneNumber = functions.https.onCall(async (data, context) => {
+  const phone = data.phone
+  const code = data.code
+
+  // Get the phone-auth document with the given phone number
+  const phoneDoc = await db.collection('phone-auth').doc(phone).get()
+
+  if (!phoneDoc.exists) {
+    return { success: false, error: 'Phone number not found.' }
+  }
+
+  const storedCode = phoneDoc.data().code
+
+  if (storedCode !== code) {
+    return { success: false, error: 'Invalid verification code.' }
+  }
+
+  // If the code matches, authenticate the user with Firebase Custom Auth
+  try {
+    // You would typically generate a UID based on the phone number or another system
+    const uid = phone
+
+    // Create a custom token (this can be used on the client to sign in)
+    const customToken = await admin.auth().createCustomToken(uid)
+
+    return { success: true, token: customToken }
+  }
+  catch (error) {
+    console.error('Error creating custom token:', error)
+    return { success: false, error: 'Failed to authenticate.' }
+  }
+})
+
+// // Generate custom token example:
+// exports.generateCustomToken = functions.https.onCall(async (data, context) => {
+//   // You would want to have some sort of validation here
+//   const token = await admin.auth().createCustomToken(data.customUid)
+//   return { token }
+// })
+
 exports.initFirestore = functions.https.onCall(async (data, context) => {
   // checks to see of the collections 'collection-data' and 'staged-users' exist if not will seed them with data
   const collectionData = await db.collection('collection-data').get()