@edgedev/firebase 1.8.11 → 1.9.1

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.

package/edgeFirebase.ts

@@ -126,6 +126,7 @@ interface newUser {
 }
 
 interface userRegister {
+  uid?: string;
   email?: string;
   password?: string;
   meta: object;
@@ -233,7 +234,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);
@@ -462,6 +463,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",
@@ -632,7 +659,7 @@ export const EdgeFirebase = class {
 
   public removeUser = async (docId: string): Promise<actionResponse> => {
     const removedFrom = [];
-    const userRef = doc(this.db, "users", docId);
+    const userRef = doc(this.db, "staged-users", docId);
     const userSnap = await getDoc(userRef);
     if (userSnap.data().roles) {
       for (const collectionPath in userSnap.data().roles) {
@@ -653,7 +680,7 @@ export const EdgeFirebase = class {
           collectionPath.replaceAll("-", "/")
         );
         if (canAssign) {
-          this.removeUserSpecialPermissions(
+         await this.removeUserSpecialPermissions(
             docId,
             collectionPath.replaceAll("-", "/")
           );
@@ -662,10 +689,11 @@ export const EdgeFirebase = class {
       }
     }
     if (removedFrom.length > 0) {
+      const response = await this.runFunction("removeNonRegisteredUser", {uid: this.user.uid, docId});
       return this.sendResponse({
         success: true,
         message: "",
-        meta: {}
+        meta: {response}
       });
     } else {
       return this.sendResponse({
@@ -892,8 +920,8 @@ export const EdgeFirebase = class {
   };
 
   private generateUserMeta = async (userMeta: newUser): Promise<actionResponse> => {
-    const roles: role[] = userMeta.roles;
-    const specialPermissions: specialPermission[] = userMeta.specialPermissions;
+    const roles: role[] = userMeta.roles || [];
+    const specialPermissions: specialPermission[] = userMeta.specialPermissions || [];
     delete userMeta.roles;
     delete userMeta.specialPermissions;
 
@@ -1411,6 +1439,7 @@ export const EdgeFirebase = class {
     }
     if (canAssign) {
       await updateDoc(doc(this.db, "staged-users/" + docId), {
+        uid: this.user.uid,
         collectionPaths: arrayRemove(collectionPath.replaceAll("/", "-")),
         ["roles." + collectionPath.replaceAll("/", "-")]: deleteField()
       });
@@ -1440,6 +1469,7 @@ export const EdgeFirebase = class {
     }
     if (canAssign) {
       await updateDoc(doc(this.db, "staged-users/" + docId), {
+        uid: this.user.uid,
         collectionPaths: arrayRemove(collectionPath.replaceAll("/", "-")),
         ["specialPermissions." + collectionPath.replaceAll("/", "-")]:
           deleteField()

package/package.json

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

package/src/firestore.rules

@@ -68,20 +68,27 @@ service cloud.firestore {
       let ruleHelper = get(/databases/$(database)/documents/rule-helpers/$(request.auth.uid)).data;
       
       return (
-              resource == null ||
-              request.resource.data.userId == resource.data.userId ||
+              request.auth.uid == request.resource.data.uid &&
               (
-                resource.data.userId == "" &&
                 (
-                  request.resource.data.userId == request.auth.uid ||
-                  request.resource.data.templateUserId == request.auth.uid
+                  (
+                     request.resource.data.userId == resource.data.userId ||
+                     resource.data.userId == ""
+                   ) &&
+                  (
+                    request.resource.data.userId == request.auth.uid ||
+                    request.resource.data.templateUserId == request.auth.uid
+                  )
+                ) ||
+                (
+                  request.resource.data.userId == resource.data.userId &&
+                  "edge-assignment-helper" in ruleHelper &&
+                  permissionUpdatesCheck(user, ruleHelper, "roles") && 
+                  permissionUpdatesCheck(user, ruleHelper, "specialPermssions")
                 )
               )
-             ) && 
-             "edge-assignment-helper" in ruleHelper &&
-             permissionUpdatesCheck(user, ruleHelper, "roles") && 
-             permissionUpdatesCheck(user, ruleHelper, "specialPermssions") && 
-             request.auth.uid == request.resource.data.uid;
+             );
+             
     }
 
 

package/src/functions.js

@@ -1,4 +1,89 @@
 // START @edge/firebase functions
+exports.removeNonRegisteredUser = functions.https.onCall(async (data, context) => {
+  if (data.uid === context.auth.uid) {
+    const stagedUser = await db.collection('staged-users').doc(data.docId).get()
+    if (stagedUser.exists) {
+      const stagedUserData = stagedUser.data()
+
+      const rolesExist = stagedUserData.roles && Object.keys(stagedUserData.roles).length !== 0
+      const specialPermissionsExist = stagedUserData.specialPermissions && Object.keys(stagedUserData.specialPermissions).length !== 0
+      const userIdExistsAndNotBlank = stagedUserData.userId && stagedUserData.userId !== ''
+
+      if (!rolesExist && !specialPermissionsExist && !userIdExistsAndNotBlank) {
+        await db.collection('staged-users').doc(data.docId).delete()
+        return { success: true, message: '' }
+      }
+      else {
+        let message = ''
+        if (rolesExist && specialPermissionsExist) {
+          message = 'Cannot delete because the non-registered user still has roles and special permissions assigned.'
+        }
+        else if (rolesExist) {
+          message = 'Cannot delete because the non-registered user still has roles assigned.'
+        }
+        else if (specialPermissionsExist) {
+          message = 'Cannot delete because the non-registered user still has special permissions assigned.'
+        }
+        else if (userIdExistsAndNotBlank) {
+          message = 'Cannot delete because the user is registered.'
+        }
+        return { success: false, message }
+      }
+    }
+  }
+  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)