@edgedev/firebase 1.8.12 → 1.9.2

package/README.md

@@ -239,6 +239,63 @@ Calling this will generate a Microsoft Sign In Popup and register the user using
 );
 ```
 
+### Inviting an Existing User to Register with a New Organization or Member
+
+To invite an existing user to register with a new organization or member's data and get the corresponding roles, use the `edgeFirebase.currentUserRegister(userRegister)` method.
+
+```javascript
+const userRegisterData = {
+  registrationCode: "12345",
+  dynamicDocumentFieldValue: "fieldName",
+};
+
+const response = await edgeFirebase.currentUserRegister(userRegisterData);
+```
+
+#### Parameters
+
+- `userRegister` (object): An object containing the user registration data. It must include a `registrationCode` property provided by the inviting organization or member. It can also include a `dynamicDocumentFieldValue` property, which is a single string representing the name of an additional data field for registration.
+
+```typescript
+interface userRegister {
+  registrationCode: string;
+  dynamicDocumentFieldValue?: string;
+}
+```
+
+#### Returns
+
+The method returns a Promise that resolves to an `actionResponse` object:
+
+```typescript
+interface actionResponse {
+  success: boolean;
+  message: string;
+  meta: {};
+}
+```
+
+Example usage:
+
+```javascript
+<script setup>
+  async function inviteExistingUser() {
+    const userRegisterData = {
+      registrationCode: "12345",
+      dynamicDocumentFieldValue: "fieldName",
+    };
+
+    const response = await edgeFirebase.currentUserRegister(userRegisterData);
+    if (response.success) {
+      console.log("Existing user invited and registered successfully");
+    } else {
+      console.error("Error inviting and registering existing user:", response.message);
+    }
+  }
+</script>
+```
+
+
 ### Explanation of permissions
 
 - **assign: boolean** - When a user has this permission for a collection they can assign other users to the collection and change permissions for that collection. For a user to be able run setUser, storeCollectionPermisions, storeUserRoles, removeUserRoles, storeUserSpecialPermissions, or removeUserSpecialPermissions, they must have assign access to any of the collection paths passed into those functions.
@@ -475,6 +532,7 @@ interface UserDataObject {
   firebaseUser: object; // contains the entire auth from firebase
   oAuthCredential: object; // contains oAuth ID and token information
   loggedIn: boolean;
+  loggingIn: boolean: // true while logging in used for loading screens
   logInError: boolean;
   logInErrorMessage: string;
   meta: object;
@@ -502,6 +560,8 @@ interface permissions {
 ```
 The reactive item **edgeFirebase.user.loggedIn** can be used in code or templates to determine if the user is logged in.
 
+**edgeFirebase.user.logginIn** is true while the user is logging in.  This can be used to show a loading screen.
+
 If there is an error logging in, **edgeFirebase.user.logInError** will be true and **edgeFirebase.user.logInErrorMessage** can be used to return that error to the user.
 
 After logging in, **edgeFirebase.logOut** becomes available.  Logging out will also automatically disconnect all FireStore listeners.

package/edgeFirebase.ts

@@ -103,6 +103,7 @@ interface UserDataObject {
   firebaseUser: object;
   oAuthCredential: { accessToken: string; idToken: string;}
   loggedIn: boolean;
+  loggingIn: boolean;
   logInError: boolean;
   logInErrorMessage: string;
   meta: object;
@@ -126,6 +127,7 @@ interface newUser {
 }
 
 interface userRegister {
+  uid?: string;
   email?: string;
   password?: string;
   meta: object;
@@ -233,7 +235,7 @@ export const EdgeFirebase = class {
 
   private functions = null;
 
-  public runFunction = async (functionName: string, data: { [key: string]: unknown }) => {
+  public runFunction = async (functionName: string, data: Record<string, unknown>) => {
     data.uid = this.user.uid;
     const callable = httpsCallable(this.functions, functionName);
     return await callable(data);
@@ -387,6 +389,7 @@ export const EdgeFirebase = class {
     await this.startCollectionPermissionsSync()
     await this.initUserMetaPermissions(docSnap);
     this.user.loggedIn = true;
+    this.user.loggingIn = false;
   };
 
   private waitForUser = async(): Promise<void> => {
@@ -405,6 +408,7 @@ export const EdgeFirebase = class {
   private setOnAuthStateChanged = (): void => {
     onAuthStateChanged(this.auth, (userAuth) => {
       if (userAuth) {
+        this.user.loggingIn = true;
         this.user.email = userAuth.email;
         this.user.uid = userAuth.uid;
         this.user.firebaseUser = userAuth;
@@ -419,6 +423,7 @@ export const EdgeFirebase = class {
         this.user.oAuthCredential.accessToken = "";
         this.user.oAuthCredential.idToken = "";
         this.user.loggedIn = false;
+        this.user.loggingIn = false;
       }
     });
   };
@@ -462,6 +467,32 @@ export const EdgeFirebase = class {
     }
   }
 
+  public currentUserRegister = async (userRegister: userRegister): Promise<actionResponse> => {
+    if (!Object.prototype.hasOwnProperty.call(userRegister, 'registrationCode') || userRegister.registrationCode === "") {
+      return this.sendResponse({
+        success: false,
+        message: "Registration code is required.",
+        meta: {}
+      });
+    }
+    // userRegister.uid = this.user.uid;
+    const result = await this.runFunction("currentUserRegister", userRegister as unknown as Record<string, unknown>);
+    const resultData = result.data as {success: boolean, message: string};
+    if (resultData.success) {
+      return this.sendResponse({
+        success: true,
+        message: "",
+        meta: {}
+      });
+    } else {
+      return this.sendResponse({
+        success: false,
+        message: resultData.message,
+        meta: {}
+      });
+    }
+  }
+
   public registerUser = async (
     userRegister: userRegister,
     authProvider: authProviders = "email",
@@ -532,6 +563,7 @@ export const EdgeFirebase = class {
         }
         const initRoleHelper = {uid: response.user.uid}
         initRoleHelper["edge-assignment-helper"] = {permissionType: "roles"}
+        this.user.loggingIn = true;
         await setDoc(doc(this.db, "rule-helpers", response.user.uid), initRoleHelper);
         await updateDoc(doc(this.db, "staged-users/" + userRegister.registrationCode), stagedUserUpdate)
         this.logAnalyticsEvent("sign_up", { uid: response.user.uid});
@@ -959,6 +991,7 @@ export const EdgeFirebase = class {
       this.user.oAuthCredential.idToken = "";
       this.user.email = "";
       this.user.loggedIn = false;
+      this.user.loggingIn = false;
       this.user.meta = {};
       this.user.roles = [];
       this.user.specialPermissions = [];
@@ -984,6 +1017,7 @@ export const EdgeFirebase = class {
       this.user.oAuthCredential.idToken = "";
       this.user.loggedIn = false;
       this.user.logInError = true;
+      this.user.loggingIn = false;
       this.user.logInErrorMessage = error.code + ": " + error.message;
     });
   };
@@ -1005,6 +1039,7 @@ export const EdgeFirebase = class {
   public user: UserDataObject = reactive({
     uid: null,
     email: "",
+    loggingIn: false,
     loggedIn: false,
     logInError: false,
     logInErrorMessage: "",   
@@ -1300,7 +1335,7 @@ export const EdgeFirebase = class {
     }
   };
 
-  public startSnapshot = async(
+  public startSnapshot = async (
     collectionPath: string,
     queryList: FirestoreQuery[] = [],
     orderList: FirestoreOrderBy[] = [],
@@ -1312,20 +1347,32 @@ export const EdgeFirebase = class {
     this.unsubscibe[collectionPath] = null;
     if (canRead) {
       const q = this.getQuery(collectionPath, queryList, orderList, max);
-      const unsubscribe = onSnapshot(q, (querySnapshot) => {
-        const items = {};
-        querySnapshot.forEach((doc) => {
-          const item = doc.data();
-          item.docId = doc.id;
-          items[doc.id] = item;
+  
+      return new Promise<actionResponse>((resolve, reject) => {
+        const unsubscribe = onSnapshot(q, (querySnapshot) => {
+          const items = {};
+          querySnapshot.forEach((doc) => {
+            const item = doc.data();
+            item.docId = doc.id;
+            items[doc.id] = item;
+          });
+          this.data[collectionPath] = items;
+          this.unsubscibe[collectionPath] = unsubscribe;
+  
+          // Resolve the Promise with the success response
+          resolve(this.sendResponse({
+            success: true,
+            message: "",
+            meta: {}
+          }));
+        }, (error) => {
+          // Reject the Promise with the error response
+          reject(this.sendResponse({
+            success: false,
+            message: `Error fetching data from "${collectionPath}": ${error.message}`,
+            meta: {}
+          }));
         });
-        this.data[collectionPath] = items;
-      });
-      this.unsubscibe[collectionPath] = unsubscribe;
-      return this.sendResponse({
-        success: true,
-        message: "",
-        meta: {}
       });
     } else {
       return this.sendResponse({

package/package.json

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

package/src/functions.js

@@ -34,6 +34,56 @@ exports.removeNonRegisteredUser = functions.https.onCall(async (data, context) =
   return { success: false, message: 'Non-registered user not found.' }
 })
 
+exports.currentUserRegister = functions.https.onCall(async (data, context) => {
+  if (data.uid === context.auth.uid) {
+    const stagedUser = await db.collection('staged-users').doc(data.registrationCode).get()
+    if (!stagedUser.exists) {
+      return { success: false, message: 'Registration code not found.' }
+    }
+    else {
+      const stagedUserData = await stagedUser.data()
+      let process = false
+      if (stagedUserData.isTemplate) {
+        process = true
+      }
+      if (!stagedUserData.isTemplate && stagedUserData.userId === '') {
+        process = true
+      }
+      if (!process) {
+        return { success: false, message: 'Registration code not valid.' }
+      }
+      const newRoles = stagedUserData.roles || {}
+      const currentUser = await db.collection('users').doc(data.uid).get()
+      const currentUserData = await currentUser.data()
+      const currentRoles = currentUserData.roles || {}
+      const currentUserCollectionPaths = currentUserData.collectionPaths || []
+      let newRole = {}
+      if (stagedUserData.subCreate && Object.keys(stagedUserData.subCreate).length !== 0 && stagedUserData.isTemplate) {
+        if (!data.dynamicDocumentFieldValue) {
+          return { success: false, message: 'Dynamic document field value is required.' }
+        }
+        const rootPath = stagedUserData.subCreate.rootPath
+        const newDoc = stagedUserData.subCreate.documentStructure
+        newDoc[stagedUserData.subCreate.dynamicDocumentField] = data.dynamicDocumentFieldValue
+        const addedDoc = await db.collection(rootPath).add(newDoc)
+        await db.collection(rootPath).doc(addedDoc.id).update({ docId: addedDoc.id })
+        newRole = { [`${rootPath}-${addedDoc.id}`]: { collectionPath: `${rootPath}-${addedDoc.id}`, role: stagedUserData.subCreate.role } }
+      }
+      const combinedRoles = { ...currentRoles, ...newRoles, ...newRole }
+      Object.values(combinedRoles).forEach((role) => {
+        if (!currentUserCollectionPaths.includes(role.collectionPath)) {
+          currentUserCollectionPaths.push(role.collectionPath)
+        }
+      })
+      await db.collection('staged-users').doc(currentUserData.stagedDocId).update({ roles: combinedRoles, collectionPaths: currentUserCollectionPaths })
+      if (!stagedUserData.isTemplate) {
+        await db.collection('staged-users').doc(data.registrationCode).delete()
+      }
+      return { success: true, message: '' }
+    }
+  }
+})
+
 exports.updateUser = functions.firestore.document('staged-users/{docId}').onUpdate((change, context) => {
   const eventId = context.eventId
   const eventRef = db.collection('events').doc(eventId)