@edgedev/firebase 1.9.23 → 2.0.3

package/edgeFirebase.ts

@@ -110,7 +110,7 @@ interface UserDataObject {
   firebaseUser: object;
   oAuthCredential: { accessToken: string; idToken: string;}
   loggedIn: boolean;
-  loggingIn: boolean;
+  loggingIn: boolean | null;
   logInError: boolean;
   logInErrorMessage: string;
   meta: object;
@@ -144,6 +144,7 @@ interface userRegister {
   meta: object;
   registrationCode: string;
   dynamicDocumentFieldValue?: string;
+  requestedOrgId?: string;
 }
 
 
@@ -423,6 +424,7 @@ export const EdgeFirebase = class {
 
   private setOnAuthStateChanged = (): void => {
     onAuthStateChanged(this.auth, (userAuth) => {
+      console.log('onAuthStateChanged')
       const oldDiv = document.getElementById("recaptcha-container");
       if (oldDiv) oldDiv.remove();
       if (userAuth) {
@@ -473,7 +475,7 @@ export const EdgeFirebase = class {
 
   public logInWithPhone = async (phoneNumber: string, phoneCode: string): Promise<void> => {
     try {
-      const verifyCode: any = await this.runFunction("verifyPhoneNumber", {phone: phoneNumber, code: phoneCode});
+      const verifyCode: any = await this.runFunction("edgeFirebase-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")) {
@@ -552,7 +554,7 @@ export const EdgeFirebase = class {
       });
     }
     // userRegister.uid = this.user.uid;
-    const result = await this.runFunction("currentUserRegister", userRegister as unknown as Record<string, unknown>);
+    const result = await this.runFunction("edgeFirebase-currentUserRegister", userRegister as unknown as Record<string, unknown>);
     const resultData = result.data as {success: boolean, message: string};
     if (resultData.success) {
       return this.sendResponse({
@@ -622,6 +624,18 @@ export const EdgeFirebase = class {
         meta: {}
       });
     }
+    if (Object.prototype.hasOwnProperty.call(userRegister, 'requestedOrgId')) {
+      if (userRegister.requestedOrgId) {
+        const result: any = await this.runFunction("edgeFirebase-checkOrgIdExists", {orgId: userRegister.requestedOrgId.toLowerCase()});
+        if (result.data.exists) {
+          return this.sendResponse({
+            success: false,
+            message: "Organization ID already exists.",
+            meta: {}
+          });
+        }
+      }
+    }
     const userRef = doc(this.db, "staged-users", userRegister.registrationCode);
     const userSnap = await getDoc(userRef);
     if (userSnap.exists()) {
@@ -680,7 +694,7 @@ export const EdgeFirebase = class {
           }
         } else if (authProvider === "phone") {
           try {
-            const verifyCode: any = await this.runFunction("verifyPhoneNumber", {phone: userRegister.phoneNumber, code: userRegister.phoneCode});
+            const verifyCode: any = await this.runFunction("edgeFirebase-verifyPhoneNumber", {phone: userRegister.phoneNumber, code: userRegister.phoneCode});
             if (verifyCode.data.success) {
               response = await signInWithCustomToken(this.auth, verifyCode.data.token);
               await updateProfile(response.user, {
@@ -714,12 +728,15 @@ export const EdgeFirebase = class {
         }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}
+        let stagedUserUpdate: {userId?: string, templateUserId?: string, dynamicDocumentFieldValue?: string, uid: string, meta: unknown, templateMeta?: unknown, requestedOrgId?: 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}
           if (Object.prototype.hasOwnProperty.call(userRegister, 'dynamicDocumentFieldValue')) {
             stagedUserUpdate = {templateUserId: response.user.uid, uid: response.user.uid, dynamicDocumentFieldValue: userRegister.dynamicDocumentFieldValue, meta: user.meta, templateMeta: metaUpdate}
           }
+          if (Object.prototype.hasOwnProperty.call(userRegister, 'requestedOrgId')) {
+            stagedUserUpdate = {templateUserId: response.user.uid, uid: response.user.uid, dynamicDocumentFieldValue: userRegister.dynamicDocumentFieldValue, meta: user.meta, templateMeta: metaUpdate, requestedOrgId: userRegister.requestedOrgId.toLowerCase()}
+          }
         }
         const initRoleHelper = {uid: response.user.uid}
         initRoleHelper["edge-assignment-helper"] = {permissionType: "roles"}
@@ -854,7 +871,7 @@ export const EdgeFirebase = class {
       }
     }
     if (removedFrom.length > 0) {
-      const response = await this.runFunction("removeNonRegisteredUser", {uid: this.user.uid, docId});
+      const response = await this.runFunction("edgeFirebase-removeNonRegisteredUser", {uid: this.user.uid, docId});
       return this.sendResponse({
         success: true,
         message: "line 704",
@@ -1206,7 +1223,7 @@ export const EdgeFirebase = class {
   public user: UserDataObject = reactive({
     uid: null,
     email: "",
-    loggingIn: false,
+    loggingIn: null,
     loggedIn: false,
     logInError: false,
     logInErrorMessage: "",   

package/package.json

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

package/src/.env.dev

@@ -0,0 +1,7 @@
+STRIPE_API_KEY=
+STRIPE_SECRET=
+STRIPE_RETURN_URL=
+OPENAI_API_KEY=
+TWILIO_SID=
+TWILIO_AUTH_TOKEN=
+TWILIO_SYSTEM_NUMBER=

package/src/.env.prod

@@ -0,0 +1,7 @@
+STRIPE_API_KEY=
+STRIPE_SECRET=
+STRIPE_RETURN_URL=
+OPENAI_API_KEY=
+TWILIO_SID=
+TWILIO_AUTH_TOKEN=
+TWILIO_SYSTEM_NUMBER=

package/src/config.js

@@ -0,0 +1,38 @@
+const functions = require('firebase-functions')
+const admin = require('firebase-admin')
+
+admin.initializeApp()
+
+const { onCall, HttpsError } = require('firebase-functions/v2/https')
+const { onSchedule } = require('firebase-functions/v2/scheduler')
+const {
+  onDocumentWritten,
+  onDocumentCreated,
+  onDocumentUpdated,
+  onDocumentDeleted,
+  Change,
+  FirestoreEvent,
+} = require('firebase-functions/v2/firestore')
+const { logger } = require('firebase-functions/v2')
+const { getFirestore } = require('firebase-admin/firestore')
+const twilio = require('twilio')
+const db = getFirestore()
+
+module.exports = {
+  onSchedule,
+  onDocumentWritten,
+  onDocumentCreated,
+  onDocumentUpdated,
+  onDocumentDeleted,
+  Change,
+  FirestoreEvent,
+  onCall,
+  HttpsError,
+  logger,
+  getFirestore,
+  functions,
+  admin,
+  twilio,
+  db,
+}
+

package/src/edgeFirebase.js

@@ -0,0 +1,309 @@
+const { onCall, HttpsError, logger, getFirestore, functions, admin, twilio, db } = require('./config.js')
+
+const authToken = process.env.TWILIO_AUTH_TOKEN
+const accountSid = process.env.TWILIO_SID
+const systemNumber = process.env.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.' }
+  }
+})
+
+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()
+  const stagedUsers = await db.collection('staged-users').get()
+  if (collectionData.empty) {
+    // create a document with the id of '-' and one called '-default-':
+    const admin = { assign: true, delete: true, read: true, write: true }
+    const editor = { assign: false, delete: true, read: true, write: true }
+    const writer = { assign: false, delete: false, read: true, write: true }
+    const user = { assign: false, delete: false, read: true, write: false }
+    await db.collection('collection-data').doc('-').set({ admin, editor, writer, user })
+    await db.collection('collection-data').doc('-default-').set({ admin, editor, writer, user })
+  }
+  if (stagedUsers.empty) {
+    const templateUser = {
+      docId: 'organization-registration-template',
+      isTemplate: true,
+      meta: {
+        name: 'Organization Registration Template',
+      },
+      subCreate: {
+        documentStructure: {
+          name: '',
+        },
+        dynamicDocumentField: 'name',
+        role: 'admin',
+        rootPath: 'organizations',
+      },
+      userId: '',
+    }
+    await db.collection('staged-users').doc('organization-registration-template').set(templateUser)
+  }
+})
+
+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.checkOrgIdExists = onCall(async (request) => {
+  const data = request.data
+  const orgId = data.orgId.toLowerCase()
+  const orgDoc = await db.collection('organizations').doc(orgId).get()
+  return { exists: orgDoc.exists }
+})
+
+exports.updateUser = functions.firestore.document('staged-users/{docId}').onUpdate(async (change, context) => {
+  const eventId = context.eventId
+  const eventRef = db.collection('events').doc(eventId)
+  const stagedDocId = context.params.docId
+  let newData = change.after.data()
+  const oldData = change.before.data()
+
+  const shouldProcess = await eventRef.get().then((eventDoc) => {
+    return !eventDoc.exists || !eventDoc.data().processed
+  })
+
+  if (!shouldProcess) {
+    return null
+  }
+
+  // Note: we can trust on newData.uid because we are checking in rules that it matches the auth.uid
+  if (newData.userId) {
+    const userRef = db.collection('users').doc(newData.userId)
+    await setUser(userRef, newData, oldData, stagedDocId)
+    await markProcessed(eventRef)
+  }
+  else {
+    if (newData.templateUserId !== oldData.templateUserId) {
+      // Check if templateUserId already exists in the staged-users collection
+      const stagedUserRef = db.collection('staged-users').doc(newData.templateUserId)
+      const doc = await stagedUserRef.get()
+
+      // If it exists, skip the creation process
+      if (doc.exists) {
+        return null
+      }
+
+      newData.isTemplate = false
+      const templateUserId = newData.templateUserId
+      newData.meta = newData.templateMeta
+      delete newData.templateMeta
+      delete newData.templateUserId
+      if (Object.prototype.hasOwnProperty.call(newData, 'subCreate') && Object.values(newData.subCreate).length > 0) {
+        const subCreate = newData.subCreate
+        delete newData.subCreate
+        const addedDoc = await db.collection(subCreate.rootPath).add({ [subCreate.dynamicDocumentField]: newData.dynamicDocumentFieldValue })
+        await db.collection(subCreate.rootPath).doc(addedDoc.id).update({ docId: addedDoc.id })
+        delete newData.dynamicDocumentFieldValue
+        const newRole = { [`${subCreate.rootPath}-${addedDoc.id}`]: { collectionPath: `${subCreate.rootPath}-${addedDoc.id}`, role: subCreate.role } }
+        if (Object.prototype.hasOwnProperty.call(newData, 'collectionPaths')) {
+          newData.collectionPaths.push(`${subCreate.rootPath}-${addedDoc.id}`)
+        }
+        else {
+          newData.collectionPaths = [`${subCreate.rootPath}-${addedDoc.id}`]
+        }
+        const newRoles = { ...newData.roles, ...newRole }
+        newData = { ...newData, roles: newRoles }
+        const stagedUserRef = db.collection('staged-users').doc(templateUserId)
+        await stagedUserRef.set({ ...newData, userId: templateUserId })
+        const userRef = db.collection('users').doc(templateUserId)
+        await setUser(userRef, newData, oldData, templateUserId)
+        await markProcessed(eventRef)
+      }
+      else {
+        const stagedUserRef = db.collection('staged-users').doc(templateUserId)
+        await stagedUserRef.set({ ...newData, userId: templateUserId })
+        const userRef = db.collection('users').doc(templateUserId)
+        await setUser(userRef, newData, oldData, templateUserId)
+        await markProcessed(eventRef)
+      }
+    }
+  }
+  await markProcessed(eventRef)
+})
+
+function setUser(userRef, newData, oldData, stagedDocId) {
+// IT's OK If "users" doesn't match exactly matched "staged-users" because this is only preventing
+// writing from outside the @edgdev/firebase functions, so discrepancies will be rare since
+// the package will prevent before it gets this far.
+  return userRef.get().then((user) => {
+    let userUpdate = { meta: newData.meta, stagedDocId }
+
+    if (Object.prototype.hasOwnProperty.call(newData, 'roles')) {
+      userUpdate = { ...userUpdate, roles: newData.roles }
+    }
+    if (Object.prototype.hasOwnProperty.call(newData, 'specialPermissions')) {
+      userUpdate = { ...userUpdate, specialPermissions: newData.specialPermissions }
+    }
+
+    if (!oldData.userId) {
+      userUpdate = { ...userUpdate, userId: newData.uid }
+    }
+    if (!user.exists) {
+      return userRef.set(userUpdate)
+    }
+    else {
+      return userRef.update(userUpdate)
+    }
+  })
+}
+
+function shouldProcess(eventRef) {
+  return eventRef.get().then((eventDoc) => {
+    return !eventDoc.exists || !eventDoc.data().processed
+  })
+}
+
+function markProcessed(eventRef) {
+  return eventRef.set({ processed: true }).then(() => {
+    return null
+  })
+}

package/src/functions.js

@@ -1,311 +1,3 @@
 // 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()
-  const stagedUsers = await db.collection('staged-users').get()
-  if (collectionData.empty) {
-    // create a document with the id of '-' and one called '-default-':
-    const admin = { assign: true, delete: true, read: true, write: true }
-    const editor = { assign: false, delete: true, read: true, write: true }
-    const writer = { assign: false, delete: false, read: true, write: true }
-    const user = { assign: false, delete: false, read: true, write: false }
-    await db.collection('collection-data').doc('-').set({ admin, editor, writer, user })
-    await db.collection('collection-data').doc('-default-').set({ admin, editor, writer, user })
-  }
-  if (stagedUsers.empty) {
-    const templateUser = {
-      docId: 'organization-registration-template',
-      isTemplate: true,
-      meta: {
-        name: 'Organization Registration Template',
-      },
-      subCreate: {
-        documentStructure: {
-          name: '',
-        },
-        dynamicDocumentField: 'name',
-        role: 'admin',
-        rootPath: 'organizations',
-      },
-      userId: '',
-    }
-    await db.collection('staged-users').doc('organization-registration-template').set(templateUser)
-  }
-})
-
-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(async (change, context) => {
-  const eventId = context.eventId
-  const eventRef = db.collection('events').doc(eventId)
-  const stagedDocId = context.params.docId
-  let newData = change.after.data()
-  const oldData = change.before.data()
-
-  const shouldProcess = await eventRef.get().then((eventDoc) => {
-    return !eventDoc.exists || !eventDoc.data().processed
-  })
-
-  if (!shouldProcess) {
-    return null
-  }
-
-  // Note: we can trust on newData.uid because we are checking in rules that it matches the auth.uid
-  if (newData.userId) {
-    const userRef = db.collection('users').doc(newData.userId)
-    await setUser(userRef, newData, oldData, stagedDocId)
-    await markProcessed(eventRef)
-  }
-  else {
-    if (newData.templateUserId !== oldData.templateUserId) {
-      // Check if templateUserId already exists in the staged-users collection
-      const stagedUserRef = db.collection('staged-users').doc(newData.templateUserId)
-      const doc = await stagedUserRef.get()
-
-      // If it exists, skip the creation process
-      if (doc.exists) {
-        return null
-      }
-
-      newData.isTemplate = false
-      const templateUserId = newData.templateUserId
-      newData.meta = newData.templateMeta
-      delete newData.templateMeta
-      delete newData.templateUserId
-      if (Object.prototype.hasOwnProperty.call(newData, 'subCreate') && Object.values(newData.subCreate).length > 0) {
-        const subCreate = newData.subCreate
-        delete newData.subCreate
-        const addedDoc = await db.collection(subCreate.rootPath).add({ [subCreate.dynamicDocumentField]: newData.dynamicDocumentFieldValue })
-        await db.collection(subCreate.rootPath).doc(addedDoc.id).update({ docId: addedDoc.id })
-        delete newData.dynamicDocumentFieldValue
-        const newRole = { [`${subCreate.rootPath}-${addedDoc.id}`]: { collectionPath: `${subCreate.rootPath}-${addedDoc.id}`, role: subCreate.role } }
-        if (Object.prototype.hasOwnProperty.call(newData, 'collectionPaths')) {
-          newData.collectionPaths.push(`${subCreate.rootPath}-${addedDoc.id}`)
-        }
-        else {
-          newData.collectionPaths = [`${subCreate.rootPath}-${addedDoc.id}`]
-        }
-        const newRoles = { ...newData.roles, ...newRole }
-        newData = { ...newData, roles: newRoles }
-        const stagedUserRef = db.collection('staged-users').doc(templateUserId)
-        await stagedUserRef.set({ ...newData, userId: templateUserId })
-        const userRef = db.collection('users').doc(templateUserId)
-        await setUser(userRef, newData, oldData, templateUserId)
-        await markProcessed(eventRef)
-      }
-      else {
-        const stagedUserRef = db.collection('staged-users').doc(templateUserId)
-        await stagedUserRef.set({ ...newData, userId: templateUserId })
-        const userRef = db.collection('users').doc(templateUserId)
-        await setUser(userRef, newData, oldData, templateUserId)
-        await markProcessed(eventRef)
-      }
-    }
-  }
-  await markProcessed(eventRef)
-})
-
-function setUser(userRef, newData, oldData, stagedDocId) {
-// IT's OK If "users" doesn't match exactly matched "staged-users" because this is only preventing
-// writing from outside the @edgdev/firebase functions, so discrepancies will be rare since
-// the package will prevent before it gets this far.
-  return userRef.get().then((user) => {
-    let userUpdate = { meta: newData.meta, stagedDocId }
-
-    if (Object.prototype.hasOwnProperty.call(newData, 'roles')) {
-      userUpdate = { ...userUpdate, roles: newData.roles }
-    }
-    if (Object.prototype.hasOwnProperty.call(newData, 'specialPermissions')) {
-      userUpdate = { ...userUpdate, specialPermissions: newData.specialPermissions }
-    }
-
-    if (!oldData.userId) {
-      userUpdate = { ...userUpdate, userId: newData.uid }
-    }
-    if (!user.exists) {
-      return userRef.set(userUpdate)
-    }
-    else {
-      return userRef.update(userUpdate)
-    }
-  })
-}
-
-function shouldProcess(eventRef) {
-  return eventRef.get().then((eventDoc) => {
-    return !eventDoc.exists || !eventDoc.data().processed
-  })
-}
-
-function markProcessed(eventRef) {
-  return eventRef.set({ processed: true }).then(() => {
-    return null
-  })
-}
-// END @edge/firebase functions
+exports.edgeFirebase = require('./edgeFirebase')
+// END @edge/firebase functions

package/src/postinstall.sh

@@ -24,11 +24,19 @@ awk '/\/\/ #EDGE FIREBASE RULES START/,/\/\/ #EDGE FIREBASE RULES END/' ./src/fi
 
 if [ ! -f "$project_root/functions/index.js" ]; then
   mkdir -p "$project_root/functions"
-  echo "const functions = require('firebase-functions')" > "$project_root/functions/index.js";
-  echo "const admin = require('firebase-admin')" >> "$project_root/functions/index.js";
-  echo "admin.initializeApp()" >> "$project_root/functions/index.js";
-  echo "const db = admin.firestore()" >> "$project_root/functions/index.js";
-fi   
+  echo "require('dotenv').config({ path: process.env.NODE_ENV === 'production' ? '.env.prod' : '.env.dev' })" > "$project_root/functions/index.js";
+fi
+
+cp ./src/edgeFirebase.js "$project_root/functions/edgeFirebase.js"
+cp ./src/config.js "$project_root/functions/config.js"
+
+if [ ! -f "$project_root/.env.dev" ]; then
+  cp ./src/.env.dev "$project_root/.env.dev"
+fi
+
+if [ ! -f "$project_root/.env.prod" ]; then
+  cp ./src/.env.prod "$project_root/.env.prod"
+fi
 
 [ "$(tail -c1 $project_root/functions/index.js)" != "" ] && echo "" >> "$project_root/functions/index.js"