An Overview of the App

The App

 I really enjoy traveling and like to find out about interesting things nearby wherever I happen to be.  I am often driving when visiting new places and thus am not necessarily able to look on my phone, so I thought: Why can't an app just read me information about nearby attractions?  I couldn't find an existing app that did, so I figured it would be pretty fun write my own.  That is how I came up with the idea for the app we are going to be building.  For now, we will call it autotoor.  


What will the app do? 

The app will leverage the user's phone's current location to lookup nearby points of interest and then read information about them to the user.  It will also display an associated picture and the text of what it reads aloud.


Where will we get the information about points of interest from?

Luckily Wikipedia offers a Geosearch API that allows you to lookup articles by GPS coordinates.  We can pass a user's GPS coordinates to this API which will return a list of articles. 


Very High-Level App Architecture




Phone App

We will build a phone app using React Native and Expo.  React Native native is an excellent choice for building mobile apps due to the extremely large React community and wealth of examples of all things React available on the web.  It will also allow us to write a single codebase that works for multiple phone platforms.  Adding Expo into the mix provides even more mobile friendly components for React as well as a CI/CD platform for building, submitting and even updating React Native apps.


Tour Service

Rather than directly calling the Wikipedia API from our phone app, we will leverage a node service which we will call the tour-service to interact with the Wikipedia API and handle any data massaging to make it presentable to our app.  By moving as much functionality out of our mobile app into a backend service as possible, we make it much easier to release simple functionality changes, since we have more control over the update process for a backend service vs that of a mobile app.  In later iterations of our app, we can also use the tour-service to implement additional functionality.

This node service will be implemented using NestJS, an opinionated Node.js framework that provides things like dependency injection, a declarative controller layer on top of express, and many other very cool features.


Wikipedia API

As mentioned above Wikipedia offers a Geosearch API that will allow us to leverage a user's coordinates to lookup a list of nearby articles.  Other Wikipedia APIs such as the MediaWiki query API can then be used to get the content of the articles.


Build, Hosting, Deployment and Infrastructure

The whole project will be built using a pnpm Turborepo monorepo for speed and efficiency.  The tour-service will run in a Docker container hosted via Cloud Run in the Google Cloud Platform (GCP) and deployed via github actions.  All of the infrastructure in GCP will be defined using Terraform and then also deployed using github actions.


What's Next?

Now that we have gone through a brief overview of the app and the technologies that will be used to build and deploy it, it's time to get started.  In the upcoming posts we will go step by step through building nearly every aspect of the app.  Look out for my next post coming soon.

Comments

Post a Comment

Popular posts from this blog

Node.js Microservice with NestJS: Part 3 - NestJS Dependency Injection

An Introduction to Dependency Injection in NestJS NestJS is a powerful framework for building efficient, reliable, and scalable server-side applications. One of the core concepts in NestJS is Dependency Injection (DI) , which is built on the Inversion of Control (IoC) design pattern. In this third installment on building a microservice using  NestJS , we'll explore what dependency injection is, how it's implemented in NestJS , and why it's crucial for building maintainable applications. We'll also provide practical examples  of how we use it in our tour-service application to illustrate these concepts and break down important topics like decorators, constructors, modules, application context, and services. For more details about the service we are building and what we have done so far, check out the following posts: Node.js Microservice with NestJS: Part 1 - Service Overview  - An overview of the microservice we will be building Node.js Microservice with NestJS: Part ...
Read more

REST APIs with Controllers - Node.js Microservice with NestJS: Part 4

Building REST APIs with Controllers in NestJS NestJS is a progressive Node.js framework that builds on top of Express and uses TypeScript , making it a fantastic choice for developers seeking a structured and scalable approach to building backend applications. In this fourth installment of the series of posts on building a Node.js microservice with NestJS , we'll explore how NestJS helps developers create declarative REST APIs using controllers, along with powerful features like decorators, Data Transfer Objects (DTOs) , validation, and type transformation. If you're familiar with JAX-RS in Java, you'll notice a similar approach to structuring APIs. For more details about the service we are building and what we have done so far, check out some of the prior posts on the topic: Node.js Microservice with NestJS: Part 1 - Service Overview  - An overview of the microservice we will be building Node.js Microservice with NestJS: Part 2 - Using the NestJS CLI  - Provisioning o...
Read more

Constructor-Based vs Property-Based Dependency Injection in NestJS - Which is Better?

Image
Constructor-Based vs Property-Based Dependency Injection in NestJS - Which is Better? Using constructor-based injection is generally considered better than property-based injection in NestJS (and in many other frameworks) for several key reasons.  Lets look at a few reasons why and some scenarios where  property-based injection  may be more appropriate. Immutability and Readability Constructor-based injection ensures that dependencies are provided at the time of object creation, making them immutable . This means that the dependencies cannot be reassigned after the object is instantiated. With property-based injection , dependencies are injected later, making them mutable. This can lead to side effects if the dependencies are modified during the object's lifetime. Constructor-based injection makes it clear what dependencies the class needs at the time of instantiation, improving code readability. Example: private readonly landmarkService : LandmarkService ; constructo...
Read more