DEV Community: Sherif Shahin

Using Firebase Cloud Functions with Nodejs and Express

Sherif Shahin — Sat, 05 Feb 2022 16:03:17 +0000

Prerequisites

You need to know how to deal with nodejs and express framework to get the most out of this post.

What's Firebase Cloud Functions

Cloud Functions for Firebase is a serverless framework that lets you automatically run backend code in response to events triggered by Firebase features and HTTPS requests. Your JavaScript or TypeScript code is stored in Google's cloud and runs in a managed environment. There's no need to manage and scale your own servers.

Initialize your nodejs project

you need to create new firebase project.
install firebase CLI

npm install -g firebase-tools

then install firebase functions and admin.

npm install firebase-functions@latest firebase-admin@latest --save

3.Run firebase login to log in via the browser and authenticate the firebase tool.

then Run firebase init functions and choose javaScript as your language.

after this commands your project will be successfully structured.

Let's start our coding journey

-now you need to import firebase functions and express framework.

in your index.js add the following lines

const functions = require('firebase-functions');

const express = require('express');
const app = express();

create our new route by create new user file then create user-route.js
in your user-route.js add the following lines

const express = require('express');
const router = express.Router();


router.get('/' , (req , res) =>{
    return res.status(200).json('hello from user route');
});

module.exports = router;

then we need to link our new route with express
in index.js add the following lines

const userRoute = require('./user/user-route');
app.use('/user',userRoute);

the final step in our code is linking express routes with firebase cloud functions in index.js

exports.app = functions.https.onRequest(app);

you now can emulate your cloud functions by using the following command

firebase emulators:start

output will be

Resources

https://firebase.google.com/docs/functions/

and That's it for this post, I hope you've learned something new, please drop me a comment if you didn't understand something, I also love to hear suggestions for improving, so if you have any, please drop me a comment.

map vs flatMap vs concatMap in RxJava With Kotlin

Sherif Shahin — Fri, 18 Dec 2020 16:05:56 +0000

map

work like kotlin's standard map function but with observables instead of collection.
transform the items by applying a function to each item.

example in Kotlin

        // create subscriber to Observable
        val subscriber = Observable.just(1,2,3,4,5)
                // use map to transform int values to random values
                .map {
                    it * 10
                }
                .subscribeBy(
                        onNext = {println(it.toInt())}
                )

the output will be :

but what if I want to return observables and subscribe all of them and merge the result?!

flatMap

Transform the items emitted by an observable into observables and keeps observing on each observable then merges the resulting observables sequences into one observable sequence.

example in Kotlin

 // create athletic class which contains subject to store athletic's sports
        class Athletic(val sports : PublishSubject<String>)

        // create subject object take Athletic datatype
        val subject = PublishSubject.create<Athletic>()


        val subscriber = subject.
                // use flatMap to transform athletic object to sports observable and subscribe it  
                flatMap {
                    it.sports
                }.subscribe {
                    println(it)
                }

        // create two Athletic objects
        val sherif = Athletic(PublishSubject.create())
        val john = Athletic(PublishSubject.create())

        // pass objects to the subject
        subject.onNext(sherif)
        subject.onNext(john)

        sherif.sports.onNext("football")
        john.sports.onNext("volleyball")
        sherif.sports.onNext("basketball")

the output will be:

football
volleyball
basketball

if we looked at the result we will find that flatmap keeps up with each observable it creates.

but what if I Want to subscribe them but get data in sequential order?!

concatMap

it's closely similar to flatMap with a little bit difference which Transform the items emitted by an observable into observables and keeps observing on each observable then merges the resulting observables sequences into one observable sequence but each sequence produced by the lambda function of concatMap will run to completion before move to the next sequence.

example in Kotlin

    // create observable emit number's types
        val numbers = Observable.just("odd" ,"even")

        // create subscriber to numbers
        val subscriber = numbers.
                concatMap { type ->
                    when(type){
                        "odd" -> {
                            println("**odd**")
                            Observable.just(1,3,5,7,9)
                        }
                        "even" -> {
                            println("**even**")
                            Observable.just(2,4,6,8,10)
                        }
                        else -> Observable.empty()
                    }
                }.subscribe {number ->
                    println(number)
                }

the output will be

**odd**
1
3
5
7
9
**even**
2
4
6
8
10

if we looked at the result we will find that the odd numbers all printed followed by the even number.

and that's it , I hope you've learned something new, please drop me a comment if you didn't understand something, I also love to hear suggestions for improving, so if you have any, please drop me a comment.

Subjects in RxJava with Kotlin

Sherif Shahin — Mon, 14 Dec 2020 02:09:53 +0000

Prerequisites

You need to know the difference between an Observable and an Observer to get the most out of this post.

What are Subjects

Subjects act both as an Observable and as an observer at the same time. Because it is an observer, it can subscribe to one or more Observables, and because it is an Observable, it can pass through the items it observes by reemitting them, and it can also emit new items. Subjects receive the next events and emit them to their subscribers.

Types of Subjects in RxJava

PublishSubject
BehaviorSubject
ReplaySubject
AsyncSubject

In this post, we will talk about PublishSubject.

PublishSubject

You can use Publish subject when you want new subscribers to be notified of new events that will come after they've subscribed.

Example in kotlin

// create publish Subject
val publishSubject = PublishSubject.create<String>()

// send element to publish subject
publishSubject.onNext("event 1")

// create subscriber to publish subject
val subscriber1 = publishSubject.subscribeBy(
        onNext = {println("subscriber 1 $it")}
)

// send element to publish subject
publishSubject.onNext("event 2")

// create another subscriber to publish subject
val subscriber2 = publishSubject.subscribeBy(
        onNext = {println("subscriber 2 $it")}
)

// send element to publish subject
publishSubject.onNext("event 3")

// dispose subscriber1
subscriber1.dispose()

// send element to publish subject
publishSubject.onNext("event 4")

// send complete event to terminates publish subject observable sequence
publishSubject.onComplete()

//dispose subscriber2 because there is no more events will come for it
subscriber2.dispose()

The output will be:

subscriber 1 event 2
subscriber 1 event 3
subscriber 2 event 3
subscriber 2 event 4

That's it for PublishSubject, I hope you've learned something new, please drop me a comment if you didn't understand something, I also love to hear suggestions for improving, so if you have any, please drop me a comment.