How to initialize app (Kotlin JS Web)?

[emptify]

I'm programming a Kotlin JS website. How can I initialize my firebase app like the following js code?

const firebaseConfig = {
apiKey: "apiKey",
authDomain: "authDomain",
projectId: "projectId",
storageBucket: "storageBucket",
messagingSenderId: "messagingSenderId",
appId: "appId",
measurementId: "measurementId"
};
const app = initializeApp(firebaseConfig);

[eugenewainaina]

val context = Application().applicationContext

FirebasePlatform.initializeFirebasePlatform(object : FirebasePlatform() {
    val storage = mutableMapOf<String, String>()
    override fun store(key: String, value: String) = storage.set(key, value)
    override fun retrieve(key: String) = storage[key]
    override fun clear(key: String) {
        storage.remove(key)
    }

    override fun log(msg: String) = println(msg)
})

val firebaseConfig = FirebaseOptions(
    apiKey = "-",
    authDomain = "-,
    projectId = "-",
    storageBucket = "-",
    gcmSenderId = "-",
    applicationId = "1:-"
)


val firebaseApp = Firebase.initialize(context = context, options = firebaseConfig)



# To test the connection:

val auth: FirebaseAuth? = try {
    Firebase.auth
} catch (e: Exception) {
    null
}

if (auth != null) {
    do something
} else {
    oops
}

[eugenewainaina]

My previous answer is using the Kotlin Firebase SDK to initialize Firebase. But I ran into problems and resolved to using JS in the jsMain to initialize Firebase.

Here (js implementation)

build.gradle jsMain

implementation(kotlin("stdlib-js"))
// Add Firebase JavaScript SDK dependency
implementation(npm("firebase", "10.12.3"))

In a separate file

import kotlin.js.Promise

@JsModule("firebase/app")
@JsNonModule
external object FirebaseApp {
    val initializeApp: (config: dynamic) -> dynamic
}

@JsModule("firebase/auth")
@JsNonModule
external object FirebaseAuth {
    val getAuth: () -> dynamic
    val createUserWithEmailAndPassword: (auth: dynamic, email: String, password: String) -> Promise<dynamic>
}


fun createUser(email: String, password: String): Promise<dynamic> {
    val auth = FirebaseAuth.getAuth()
    return FirebaseAuth.createUserWithEmailAndPassword(auth, email, password)
}

fun initFirebase() {
    val firebaseConfig = js(
        """
            {
                apiKey: "-",
                authDomain: "-",
                projectId: "-",
                storageBucket: "-",
                messagingSenderId: "-",
                appId: "1:-"
            }
            """
    )

    console.log(FirebaseApp.initializeApp(firebaseConfig))
}

Then call init and try to create a user in auth to see if it works

    initFirebase()
    
    createUser("example@gmail.com", "Password_123")
        .then { userCredential: dynamic ->
            val user = userCredential.user
            console.log("User created successfully. User ID: ${user.uid}")
        }
        .catch { error ->
            val errorMessage = error.message
            console.error("Error creating user: $errorMessage")
        }

It worked, but the code and API key were visible in dev tools sources tab.

I realised I could use the Java server initialization to do it in jvmMain since Kotlin and Java are cool with each other.

For the Kotlin + Java (for Firebase Server initialization) ->
Follow this first (https://firebase.google.com/docs/admin/setup) to set up Firebase Project and get service account json file.

Get Java dependency declared in jvmMain dependencies

implementation("com.google.firebase:firebase-admin:9.3.0")

Then

import com.google.auth.oauth2.GoogleCredentials
import com.google.firebase.FirebaseApp
import com.google.firebase.FirebaseOptions
import java.io.FileInputStream

fun initializeFirebase() {
    val serviceAccount =
        FileInputStream("FIREBASE_SERVICE_ACCOUNT_PATH.json")

    val options = FirebaseOptions.builder()
        .setCredentials(GoogleCredentials.fromStream(serviceAccount))
        //.setDatabaseUrl("https://your-project-id.firebaseio.com") 
        .build()

    FirebaseApp.initializeApp(options)
}

then call initializeFirebase() to initialize it. Probably in a main function

To test if it was initialized, try connecting to Auth:

import com.google.firebase.auth.FirebaseAuth

try {
    FirebaseAuth.getInstance().also {
        println("FirebaseAuth instance available: $it")
    }
} catch (e: IllegalStateException) {
    println("FirebaseAuth instance not available: ${e.message}")
} catch (e: Exception) {
    println("An error occurred: ${e.message}")
}

This, of course, works.