@edgedev/create-edge-app 1.0.17 → 1.0.19

package/.env

@@ -0,0 +1,11 @@
+VITE_FIREBASE_API_KEY=
+VITE_FIREBASE_AUTH_DOMAIN=
+VITE_FIREBASE_PROJECT_ID=
+VITE_FIREBASE_STORAGE_BUCKET=
+VITE_FIREBASE_MESSAGING_SENDER_ID=
+VITE_FIREBASE_APP_ID=
+VITE_FIREBASE_MEASUREMENT_ID=
+VITE_FIREBASE_EMULATOR_AUTH=
+VITE_FIREBASE_EMULATOR_FIRESTORE=
+VITE_FIREBASE_EMULATOR_FUNCTIONS=
+REGISTRATION_CODE=organization-registration-template

package/.env.dev

@@ -0,0 +1,11 @@
+VITE_FIREBASE_API_KEY=
+VITE_FIREBASE_AUTH_DOMAIN=
+VITE_FIREBASE_PROJECT_ID=
+VITE_FIREBASE_STORAGE_BUCKET=
+VITE_FIREBASE_MESSAGING_SENDER_ID=
+VITE_FIREBASE_APP_ID=
+VITE_FIREBASE_MEASUREMENT_ID=
+VITE_FIREBASE_EMULATOR_AUTH=9099
+VITE_FIREBASE_EMULATOR_FIRESTORE=8080
+VITE_FIREBASE_EMULATOR_FUNCTIONS=5001
+REGISTRATION_CODE=organization-registration-template

package/app.vue

@@ -68,7 +68,7 @@ onMounted(() => {
     changeTheme('light')
   }
 })
-edgeFirebase.runFunction('initFirestore', {})
+edgeFirebase.runFunction('edgeFirebase-initFirestore', {})
 edgeGlobal.edgeState.userRoles = [
   {
     name: 'Admin',

package/bin/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 console.log('Script started')
 const { execSync } = require('child_process')
+const fs = require('fs')
+const path = require('path')
 
 const runCommand = (command) => {
   try {
@@ -14,10 +16,34 @@ const runCommand = (command) => {
   return true
 }
 
+const modifyPackageJson = (repoName) => {
+  try {
+    const packageJsonPath = path.join(repoName, 'package.json')
+    const packageJsonData = fs.readFileSync(packageJsonPath, 'utf-8')
+    const packageJsonObj = JSON.parse(packageJsonData)
+
+    // Modify the properties
+    delete packageJsonObj.version
+    delete packageJsonObj.bin
+    packageJsonObj.name = repoName
+    packageJsonObj.description = `A really cool Edge App for ${repoName}`
+
+    // Write the file back
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJsonObj, null, 2))
+  }
+  catch (err) {
+    console.error('Failed to modify package.json', err)
+    return false
+  }
+  return true
+}
+
 const repoName = process.argv[2]
 const gitCheckoutCommand = `git clone --depth 1 https://github.com/Edge-Marketing-and-Design/edgeApp.git ${repoName}`
+const removeGitDirCommand = `rm -rf ${repoName}/.git`
 const installDependenciesCommand = `cd ${repoName} && pnpm install`
 const installFunctionDependenciesCommand = `cd ${repoName}/functions && npm install`
+const cloneFirebaseFrameworkCommand = `cd ${repoName} && git clone https://github.com/Edge-Marketing-and-Design/edgeFirebaseFramework`
 
 console.log(`Cloning with name ${repoName}...`)
 const checkedOut = runCommand(gitCheckoutCommand)
@@ -25,6 +51,18 @@ if (!checkedOut) {
   process.exit(1)
 }
 
+console.log(`Removing .git directory from ${repoName}...`)
+const removedGitDir = runCommand(removeGitDirCommand)
+if (!removedGitDir) {
+  process.exit(1)
+}
+
+console.log(`Modifying package.json for ${repoName}...`)
+const modifiedPackageJson = modifyPackageJson(repoName)
+if (!modifiedPackageJson) {
+  process.exit(1)
+}
+
 console.log(`Installing dependencies for ${repoName}...`)
 const installedDeps = runCommand(installDependenciesCommand)
 if (!installedDeps) {
@@ -37,5 +75,11 @@ if (!installedFunctionDeps) {
   process.exit(1)
 }
 
+console.log(`Cloning Firebase Framework inside ${repoName}...`)
+const clonedFirebaseFramework = runCommand(cloneFirebaseFrameworkCommand)
+if (!clonedFirebaseFramework) {
+  process.exit(1)
+}
+
 console.log(`Successfully created ${repoName}!`)
 console.log(`cd into ${repoName} and run 'sh firebase_init.sh' to initialize your firebase project.`)

package/deploy.sh

@@ -1,6 +1,5 @@
 pnpm run generate
-firebase functions:config:set openai.api_key="SOME_API_KEY"
-firebase functions:config:get
+export NODE_ENV=production
 firebase deploy --only functions
 firebase deploy --only hosting
 firebase deploy --only firestore

package/emulator.sh

@@ -14,4 +14,5 @@ DIR="./firebase_data"
 if [ ! -d "$DIR" ]; then
  cp -r ./firebase_data_emulator_seed ./firebase_data
 fi
+export NODE_ENV=development
 firebase emulators:start --import ./firebase_data --export-on-exit

package/firebase_init.sh

@@ -1,6 +1,18 @@
-# Prompt for the project ID
+# Prompt for the Firebase configuration values
 echo "Please enter your Firebase project ID:"
 read project_id
+echo "Please enter your Firebase API key:"
+read api_key
+echo "Please enter your Firebase Auth domain:"
+read auth_domain
+echo "Please enter your Firebase storage bucket:"
+read storage_bucket
+echo "Please enter your Firebase messaging sender ID:"
+read messaging_sender_id
+echo "Please enter your Firebase app ID:"
+read app_id
+echo "Please enter your Firebase measurement ID:"
+read measurement_id
 
 # Check if project_id is empty
 if [ -z "$project_id" ]; then
@@ -36,4 +48,30 @@ fi
 # Restore firestore.rules from backup
 if [ -f ./firestore.rules.temp ]; then
   mv ./firestore.rules.temp ./firestore.rules
-fi
+fi
+
+# Create the .env file
+echo "VITE_FIREBASE_API_KEY=$api_key" > .env
+echo "VITE_FIREBASE_AUTH_DOMAIN=$auth_domain" >> .env
+echo "VITE_FIREBASE_PROJECT_ID=$project_id" >> .env
+echo "VITE_FIREBASE_STORAGE_BUCKET=$storage_bucket" >> .env
+echo "VITE_FIREBASE_MESSAGING_SENDER_ID=$messaging_sender_id" >> .env
+echo "VITE_FIREBASE_APP_ID=$app_id" >> .env
+echo "VITE_FIREBASE_MEASUREMENT_ID=$measurement_id" >> .env
+echo "VITE_FIREBASE_EMULATOR_AUTH=" >> .env
+echo "VITE_FIREBASE_EMULATOR_FIRESTORE=" >> .env
+echo "VITE_FIREBASE_EMULATOR_FUNCTIONS=" >> .env
+echo "REGISTRATION_CODE=organization-registration-template" >> .env
+
+# Create the .env.dev file
+echo "VITE_FIREBASE_API_KEY=$api_key" > .env.dev
+echo "VITE_FIREBASE_AUTH_DOMAIN=$auth_domain" >> .env.dev
+echo "VITE_FIREBASE_PROJECT_ID=$project_id" >> .env.dev
+echo "VITE_FIREBASE_STORAGE_BUCKET=$storage_bucket" >> .env.dev
+echo "VITE_FIREBASE_MESSAGING_SENDER_ID=$messaging_sender_id" >> .env.dev
+echo "VITE_FIREBASE_APP_ID=$app_id" >> .env.dev
+echo "VITE_FIREBASE_MEASUREMENT_ID=$measurement_id" >> .env.dev
+echo "VITE_FIREBASE_EMULATOR_AUTH=9099" >> .env.dev
+echo "VITE_FIREBASE_EMULATOR_FIRESTORE=8080" >> .env.dev
+echo "VITE_FIREBASE_EMULATOR_FUNCTIONS=5001" >> .env.dev
+echo "REGISTRATION_CODE=organization-registration-template" >> .env.dev

package/functions/.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/functions/.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/functions/config.js

@@ -0,0 +1,21 @@
+const functions = require('firebase-functions')
+const admin = require('firebase-admin')
+
+admin.initializeApp()
+
+const { onCall, HttpsError } = require('firebase-functions/v2/https')
+const { logger } = require('firebase-functions/v2')
+const { getFirestore } = require('firebase-admin/firestore')
+const twilio = require('twilio')
+const db = getFirestore()
+
+module.exports = {
+  onCall,
+  HttpsError,
+  logger,
+  getFirestore,
+  functions,
+  admin,
+  twilio,
+  db,
+}

package/functions/edgeFirebase.js

@@ -0,0 +1,302 @@
+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.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
+  })
+}