DEV Community: Asif

Enhancing Backend Security: Safeguarding Firebase App Check for Flutter Apps

Asif — Fri, 13 Oct 2023 08:07:05 +0000

In the realm of mobile app development, ensuring robust security for backend resources is paramount. Firebase App Check stands as a pivotal security feature that ensures exclusive access to resources within your Firebase project. While its primary role is to fortify Firebase-related services, there exists a compelling need to extend its protective mantle over non-Firebase backends and APIs utilized by your Flutter app. This article delves into the intriguing concept of employing Firebase App Check to shield custom backends and REST APIs that underlie your Flutter application.

App Check: A Bird's-Eye View:

Firebase App Check operates by generating tokens that are app-specific and undergo verification by Firebase services to establish the authenticity of incoming requests. However, when it comes to safeguarding custom APIs, a more intricate choreography is required, encompassing both the client-side and server-side realms.

The Intricate Dance: Protecting Custom APIs

Client-Side Configuration:

To initiate the protective ballet, your Flutter app must first be outfitted to conjure App Check tokens and enfold them within API requests. This necessitates the integration of the app_check plugin and invocation of initializeAppCheck() on your FirebaseApp instance.

The culmination of this setup allows for the generation of App Check tokens, subsequently woven into the fabric of your backend API requests:

   String token = await FirebaseAppCheck.instance.getToken(true);

The token then adorns your API request as a header or parameter:

   http.get(
     "/api/user",
     headers: {
       "X-Firebase-AppCheck": token,
     },
   );

Server-Side Verification:

As the performance unfolds on the server stage, App Check tokens demand validation, a task deftly performed by the Firebase Admin SDK. For the Node.js domain, the rhapsody goes as follows:

   import admin from "firebase-admin";

   async function verifyToken(token) {
     const claims = await admin
       .appCheck()
       .verifyToken(token);

     // Token attains its zenith of validity sans any error
     // Employ claims.uid for user identification
   }

For other arenas, a gaze upon the Admin SDK documentation will illuminate the path toward token verification. This validation operetta orchestrates trust in the app's origin, with a rhythmic Express middleware weaving the narrative:

   function checkAppToken(req, res, next) {

     const token = req.headers['x-firebase-appcheck'];

     try {
       const claims = admin.appCheck().verifyToken(token);
       next();
     } catch {
       res.status(401).send("Invalid token"); 
     }

   }

Curtain Call: The Grand Finale:

In the denouement, the harmonious convergence of Firebase App Check within Flutter applications and its synchronization with token validation within the backend harmoniously culminates in an impervious shield for any custom API or resource. This masterstroke fends off potential vulnerabilities like CSRF attacks and guards against the machinations of unauthorized interlopers.

With succinctly scripted verses of code harmonizing the dance between the app and the server, Firebase App Check emerges as a powerful sentinel, casting its protective aura over the entire stack. The Firebase Admin SDK, akin to a conductor of this symphony, offers an effortless means to verify tokens across a spectrum of platforms and environments, lending an air of serenity to the intricate interplay of security.

Macros to the Rescue! Add Pagination to Non-DB Collections in Laravel

Asif — Thu, 27 Jul 2023 07:26:17 +0000

Laravel's powerful Collection class provides many helpful methods for working with arrays of data. However, the built-in paginate method only works on Eloquent query builder and database results.

If you want to paginate a standard Laravel Collection instance, such as from an array or other custom data source, you're out of luck. Or are you?

By defining a custom macro, we can add pagination capabilities to any Collection instance in Laravel. Here's how it works...

Defining the Pagination Macro

Laravel allows you to define custom macros on existing classes to augment them with new functionality. We can utilize this to create a reusable paginate macro on the Collection class.

Inside the boot method of a service provider, like AppServiceProvider, we'll define the macro:

use Illuminate\Support\Collection;
use Illuminate\Pagination\LengthAwarePaginator;

Collection::macro('paginate', function ($perPage = 15, $pageName = 'page', $page = null, $options = []) {

  // Resolve current page from request  
  $page = $page ?: LengthAwarePaginator::resolveCurrentPage($pageName);

  // Paginate the Collection  
  return new LengthAwarePaginator(
      $this->forPage($page, $perPage),
      $this->count(), 
      $perPage,
      $page,
      $options
  );

});

The macro creates a new LengthAwarePaginator instance which will handle the pagination render logic and links. We just need to pass the specific page's chunk of data from the collection using forPage, as well as the total collection count.

Paginating a Collection

With the macro defined, we can now paginate non-DB collections:

$collection = collect(range(1, 100)); // a Collection instance

$paginated = $collection->paginate(10); // 10 items per page

var_dump($paginated->items()); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] on page 1

The macro handles all the complexity of slicing the collection into pages and generating the paginator instance.

Custom Pagination Super Powers!

Defining custom macros provides tremendous flexibility to expand Laravel's base classes. In this case, we've given all collections the ability to be paginated with a simple, expressive syntax.

While less efficient for giant data sets, this approach is great for smaller arrays or collections not coming directly from a database query.

So don't limit yourself to just paginating Eloquent results. With a bit of macro magic, you can bring pagination powers to any Laravel collection!

Validating Base64 Images by Size in Laravel: A How-to Guide

Asif — Wed, 12 Jul 2023 10:09:20 +0000

As Laravel developers, we often need to validate uploaded images to ensure they meet certain size requirements. Out of the box, Laravel's validation rules like max only work on numeric values, not base64-encoded images.

In this post, we'll walk through extending Laravel's validation to handle custom base64 image size validation. By writing a custom validation rule, we can reuse this logic anywhere image uploads are required in our app.

Custom Validation Rule

All custom validation rules are registered by extending the Validator in the boot method of our AppServiceProvider. First, we'll use Laravel's Validator::extend method to define the logic:

Validator::extend('base64_image_size', function ($attribute, $value, $parameters, $validator) {

  // Decode the image
  $decodedImage = base64_decode($value);

  // Get image size in kilobytes 
  $imageSize = strlen($decodedImage) / 1024;

  // Check if image is below max size
  return $imageSize <= $parameters[0]; 

});

Here we are decoding the base64-encoded image to get its binary size in bytes. Then we convert to kilobytes to compare against the maximum size defined in the parameters. If the image is below the max size, the validation passes.

Custom Error Messages

Next, we'll customize the error message using the Validator::replacer method:

Validator::replacer('base64_image_size', function ($message, $attribute, $rule, $parameters) {
  return str_replace([':attribute', ':max'], [$attribute, $parameters[0]], $message);
});

This replaces :attribute with the field name and :max with the defined max size. The message itself is defined in the resources/lang/xx/validation.php language file:

'base64_image_size' => 'The :attribute must not be larger than :max KB.',

Usage

Finally, we can use this custom rule during validation:

$validator = Validator::make($request->all(), [
  'image' => 'required|base64_image_size:500',
]);

if ($validator->fails()) {
  // Image too large
}

By extending Laravel's validation capabilities, we've built a reusable way to validate base64 image sizes across our application. The same approach can be used for any validation logic that doesn't fit neatly into the built-in rules.

Uncovering Hidden Gems: PostgreSQL Window Functions You May Not Know About

Asif — Wed, 22 Mar 2023 09:30:03 +0000

Welcome, fellow database fans! Today, we'll delve into the world of PostgreSQL window functions and look at some lesser-known truths that can help you improve your database querying skills. So strap in and let's get started.

What are Window Functions?

Window functions are a powerful feature of SQL that allow you to perform calculations across a set of rows related to the current row. This allows you to carry out advanced calculations, such as running totals, moving averages, and rank calculations.

In PostgreSQL, window functions are used in conjunction with the OVER() clause, which defines the range or "window" of rows to be used for the calculation.

Lesser-Known Facts about PostgreSQL Window Functions

1. Flexible Window Frames

You might be familiar with the default sliding window frame, which is defined as ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW. However, PostgreSQL offers several other options for defining window frames, such as RANGE and GROUPS. This allows you to create custom window frames that suit your specific needs.

For example, you can create a moving average over a specific range of rows:

SELECT value, AVG(value) OVER (ORDER BY date ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)
FROM your_table;

2. Multiple Window Functions in a Single Query

PostgreSQL allows you to use multiple window functions within a single query. This enables you to perform complex calculations and aggregations efficiently, without the need for multiple subqueries.

Consider the following example, which calculates both the running total and running average of sales:

SELECT date, sale_amount,
       SUM(sale_amount) OVER (ORDER BY date) AS running_total,
       AVG(sale_amount) OVER (ORDER BY date) AS running_average
FROM sales;

3. Partitioning with Window Functions

Partitioning is a powerful feature that allows you to divide your dataset into smaller groups based on one or more columns. By using the PARTITION BY clause with window functions, you can perform calculations on each group independently.

For instance, you might want to calculate the cumulative sum of sales for each product:

SELECT product_id, date, sale_amount,
       SUM(sale_amount) OVER (PARTITION BY product_id ORDER BY date) AS product_running_total
FROM sales;

4. Custom Aggregates in Window Functions

PostgreSQL allows you to use custom aggregate functions within window functions. This means you can create your own aggregate functions and use them in your window calculations.

For example, you might want to calculate the moving median of a dataset:

CREATE AGGREGATE median(anyelement) (
  SFUNC=array_append,
  STYPE=anyarray,
  FINALFUNC=array_median
);

SELECT value, median(value) OVER (ORDER BY date ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)
FROM your_table;

5. Use Window Functions with DISTINCT

You can use window functions in combination with the DISTINCT keyword to calculate unique values within a window frame. This can be helpful when you want to perform calculations on a distinct set of values.

For example, you might want to calculate the number of unique customers per day:

SELECT date,
       COUNT(DISTINCT customer_id) OVER (ORDER BY date) AS unique_customers
FROM sales;

Conclusion

PostgreSQL window functions are a very strong part of your SQL toolkit. They include several features that aren't as well-known but can help you conduct complex computations and groupings quickly. By learning these hidden jewels, you can improve your database querying skills and become a real Database Ninja.

Happy querying!

Get the count of affected rows with ease: The power of the RETURNING clause in Postgres

Asif — Wed, 11 Jan 2023 13:19:29 +0000

When working with databases, it is frequently vital to know how many rows have been changed by a query, and this is especially true when conducting operations such as updates or removals. Through its RETURNING clause, Postgres offers a method that is both powerful and versatile for doing this task.

Postgres's RETURNING clause makes it possible to retrieve both the data of the impacted rows and the total number of rows that were modified or deleted. The RETURNING clause is used to get certain columns from a database. It is appended at the end of a query.

For example, to update all rows in a table where a certain condition is true and return the number of affected rows, you would use the following query:

UPDATE mytable SET mycolumn = 'new value' WHERE mycondition = true RETURNING *;

This query would update the data of all rows that fit the condition "mycondition = true" and it would return the data of the rows that were changed.

In the same way that you would use the following query if you wanted to use the RETURNING clause with the DELETE statement, you also have the option to do so.

DELETE FROM mytable WHERE mycondition = true RETURNING *;

It's important to remember that the RETURNING clause only works with update and delete statements, not with select statements. It's also only available in Postgres, not in other RDBMS.

In conclusion, the RETURNING clause in Postgres is a powerful tool that makes it easy to find out how many rows are affected by update and delete queries. it can make it much easier to write robust and reliable code that works with databases.

Effortlessly manage configuration data in your Node.js microservices with nconf

Asif — Mon, 09 Jan 2023 12:27:55 +0000

Building microservices requires careful attention to detail in the area of configuration management. It will be much simpler for you to launch and maintain your services as a result of this ability to segregate configuration data from code. In this post, we'll take a look at how to manage configuration data in Node.js microservices by using the nconf package.

Why Should You Use nconf?

There are several good reasons why you should consider using nconf as the configuration management tool for your Node.js microservices, including the following:

Flexibility: nconf offers you the ability to load configuration data from a wide number of sources, including command-line arguments, environment variables, a configuration file, and default settings. Because of this, it is simple to modify the behaviour of your microservices in accordance with the environment they are running in
Ease of use: nconf's application programming interface (API) is quite straightforward, which makes retrieving and setting configuration data very simple. Additionally, it supports hierarchical data structures, which enables you to store and retrieve configuration settings that are nested within one another
Well documented: because it is so well documented, both learning it and putting it to use won't be difficult at all, thanks to nconf's extensive documentation and several working examples.

Example

Here is an example of how you might use nconf in a Node.js microservice:

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

// Initialize nconf to use (in-order):
//   1. Command-line arguments
//   2. Environment variables
//   3. A configuration file
//   4. Default values
nconf.argv().env().file({ file: 'config.json' }).defaults({
  port: 3000,
  host: 'localhost'
});

const app = express();

// Get the value of the 'port' key from the configuration data
const port = nconf.get('port');

app.listen(port, () => {
  console.log(`Microservice listening on port ${port}`);
});

This piece of code generates an Express app and makes use of nconf to load configuration data from a configuration file, command-line arguments, environment variables, and other sources, in addition to using default values. After that, the get() method is used in order to acquire the value of the port key from the configuration data, and it then begins the server process on the port that was given.

After that, you will be able to add routes to the application, which will enable customers to interact with the microservice as required. As an illustration, you can decide to build a route in order to obtain the currently active configuration data:

app.get('/config', (req, res) => {
  res.json(nconf.get());
});

This route retrieves all of the configuration data by utilizing the get() method, and then gives it back to the client in the form of a JSON object.

Boost Your Query Performance with Function-Based Indexes in PostgreSQL

Asif — Wed, 04 Jan 2023 12:19:29 +0000

Are you fed up with slow PostgreSQL queries that search for case-insensitive matches? Look no farther than indexes based on functions!

An index that is constructed based on the result of a function or expression is known as a function-based index. This means that it can be used to accelerate searches that repeatedly evaluate the same function or expression.

For example, let's say you have a table called employees that contains a column called first_name. You frequently run queries that search for employees with a given first name, but you want the search to be case-insensitive. One way to achieve this is to create a function-based index on the lower() function of the first_name column:

CREATE INDEX lower_first_name_idx ON employees (lower(first_name));

Now, when you run a query like the following:

SELECT * FROM employees WHERE lower(first_name) = 'john';

PostgreSQL will use the lower_first_name_idx index to search for rows that match the condition, which should be faster than a full table scan.

It's important to remember that function-based indexes can only be used if the indexed expression is in the WHERE clause of a query and is used in an exact match (i.e., = or IN) or a range condition (i.e., BETWEEN). If the expression is used in a SELECT list or an ORDER BY clause, they can't be used.

So, if you want to make your queries run faster, think about using function-based indexes in PostgreSQL the next time you want to do that. Your database will thank you, as will your users.

How to Save Unmatched Text in a jQuery Select2 Dropdown with an AJAX Call

Asif — Tue, 03 Jan 2023 12:30:25 +0000

jQuery Select2 is a powerful dropdown component that allows users to search for and select items from a list. It's easy to use and can be changed in many ways, making it a popular choice for web developers.

In this tutorial, we'll learn how to use a jQuery Select2 dropdown to search for text inside a database using an AJAX call. We'll also learn how to deal with the Enter key and save the text typed; into the database if there are no search results.

First, let's initialize the Select2 dropdown and set the AJAX call parameters:

$(document).ready(function() {
  // Initialize the Select2 dropdown
  $('#mySelect2').select2({
    // Set the AJAX call parameters
    ajax: {
      url: '/search',
      dataType: 'json',
      delay: 250,
      data: function (params) {
        return {
          q: params.term, // search term
          page: params.page
        };
      },
      processResults: function (data, params) {
        // parse the results into the format expected by Select2
        // since we are using custom formatting functions we do not need to
        // alter the remote JSON data, except to indicate that infinite
        // scrolling can be used
        params.page = params.page || 1;

        return {
          results: data.items,
          pagination: {
            more: (params.page * 30) < data.total_count
          }
        };
      },
      cache: true
    },
    minimumInputLength: 1,
    templateResult: formatRepo, // template for the results
    templateSelection: formatRepoSelection // template for the selected item
  });
});

In this code, we are using an AJAX call to search for text in a database. The minimumInputLength parameter is set to 1, so the AJAX call is only triggered when the user enters at least one character in the dropdown. We are also using templateResult and templateSelection to customize the display of the results and the selected item.

Next, let's figure out what to do when the Enter key is pressed and save the entered text to the database if no search results are found:

// Handle the Enter key press on the Select2 dropdown
$('#mySelect2').on('keypress', function(e) {
  var keyCode = e.keyCode || e.which;

  if (keyCode === 13) {
    // Get the entered text
    var text = $(this).val();

    // Check if there are no search results
    if ($('.select2-results__option--highlighted').length === 0) {
      // Save the text to the database via an AJAX call
      saveTextToDatabase(text);

      // Reset the Select2 dropdown
      $(this).val(null).trigger('change');
    }
  }
});

// Function to save the text to the database via an AJAX call
function saveTextToDatabase(text) {
  $.ajax({
    url: '/save',
    type: 'POST',
    data: {text: text},
    success: function(response) {
      console.log('Text saved to database: ' + text);
    },
    error: function(error) {
      console.log(error);
    }
  });
}

This may come in handy for adding new records to the database and ensuring that the list is always up to date. This functionality may be effortlessly added to any of our online applications with just a few lines of code.

Dynamically Change the Content-Disposition of an S3 Object URL

Asif — Thu, 29 Dec 2022 12:10:29 +0000

The Content-Disposition response header of an S3 object can be changed dynamically by modifying the header value in the HTTP response that is returned when the object's URL is accessed.

One way to do this is to use an AWS Lambda function to intercept the request for the object's URL and modify the Content-Disposition response header before returning the response to the browser. This allows you to change the Content-Disposition value dynamically based on the request or other conditions.

Here's an example of a Lambda function that changes the Content-Disposition value based on the value of a query parameter in the request URL:

exports.handler = async (event) => {
  // Get the object key and bucket from the event
  const key = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, ' '));
  const bucket = event.Records[0].s3.bucket.name;

  // Get the request query parameters
  const params = event.Records[0].cf.request.querystring;

  // Set the Content-Disposition value based on the "download" query parameter
  let contentDisposition;
  if (params.includes('download=1')) {
    contentDisposition = 'attachment';
  } else {
    contentDisposition = 'inline';
  }

  // Get the object from S3
  const s3 = new AWS.S3();
  const s3Object = await s3.getObject({
    Bucket: bucket,
    Key: key
  }).promise();

  // Create the response
  const response = {
    status: '200',
    statusDescription: 'OK',
    headers: {
      'Content-Type': [{
        key: 'Content-Type',
        value: s3Object.ContentType
      }],
      'Content-Disposition': [{
        key: 'Content-Disposition',
        value: contentDisposition
      }]
    },
    body: s3Object.Body
  };

  // Return the response
  return response;
};

To use this Lambda function, you would need to set up an Amazon CloudFront distribution that points to your S3 bucket and associates the Lambda function with the distribution as an origin request trigger. Then, you can access the object's URL through the CloudFront distribution and use the download query parameter to control whether the object is rendered in the browser window or downloaded.

For example, the following URL would cause the object to be downloaded:

https://my-cloudfront-distribution.com/path/to/object.ext?download=1

And the following URL would cause the object to be rendered in the browser window:

https://my-cloudfront-distribution.com/path/to/object.ext

With this setup, you can easily switch between rendering the object in the browser window and forcing a download without having to manually change the Content-Disposition value.

Displaying PDF Files in an Iframe: A Simple Solution

Asif — Wed, 21 Dec 2022 13:24:35 +0000

Are you looking for a way to embed a PDF file on your website without relying on external services or plugins? If so, then you're in luck! In this tutorial, we'll show you how to use PHP and cURL to download the content of a PDF file from a URL and display it in an iframe.

First, let's start by creating a function that uses cURL to download the PDF file:



function displayPdfFromUrl($url) {
  // Initialize cURL session
  $ch = curl_init();

  // Set cURL options
  curl_setopt($ch, CURLOPT_URL, $url);
  curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

  // Execute cURL request
  $data = curl_exec($ch);

  // Close cURL session
  curl_close($ch);

  // Return PDF file content
  return $data;
}

This function takes a URL as an argument and uses cURL to download the content of the PDF file at that URL. The content is then returned as a string.

Next, we can use the base64_encode function to encode the PDF data as a base64 string, which we can then use as the src attribute for an iframe element:

That's all there is to it! With just a few lines of code, you can easily display PDF files on your website without relying on external services or plugins.

How to Set Up a Cron Job to Update Your Firebase Collection

Asif — Tue, 20 Dec 2022 07:04:00 +0000

Are you tired of manually updating your Firebase collection? Do you want a way to automate the process and save yourself time? Then a cron job is the solution you need!

A cron job is a task that is scheduled to run at a specific time or interval. In this tutorial, we'll show you how to set up a cron job using NodeJS, Express, and TypeScript to update your Firebase collection every 5 minutes.

Prerequisites

Before you get started, make sure you have the following tools installed on your machine:

NodeJS
Express
TypeScript

Step 1: Install the Firebase SDK

To access and update your Firebase database from your NodeJS code, you'll need to install the Firebase SDK for NodeJS. You can do this by running the following command:

npm install firebase-admin

Step 2: Initialize the Firebase Admin SDK

Once you have the Firebase SDK installed, you'll need to initialize the Firebase Admin SDK by providing it with the appropriate credentials. You can find the credentials in the Firebase console under the "Project Settings" section.

To initialize the Firebase Admin SDK in your code, use the following lines:

import * as admin from 'firebase-admin';

admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  databaseURL: "https://<DATABASE_NAME>.firebaseio.com"
});

Step 3: Update the Firebase Collection

Now that you have initialized the Firebase Admin SDK, you can use it to access and update your Firebase database. For example, you can update a specific collection in your database using the following code:

const db = admin.firestore();
const collectionRef = db.collection('<COLLECTION_NAME>');

collectionRef.update({
  field1: 'new value1',
  field2: 'new value2'
});

Step 4: Set Up a Cron Job

To set up a cron job that runs every 5 minutes, you'll need to use a package called "node-cron". You can install this package by running the following command:

npm install node-cron

Once you have node-cron installed, you can use it to schedule a task to run every 5 minutes by using the following code:

import * as cron from 'node-cron';

cron.schedule('*/5 * * * *', () => {
  // your code to update the Firebase collection goes here
});

Step 5: Set Up an HTTP Server

Finally, you'll need to set up an HTTP server using Express in order to run your cron job. You can do this by using the following code:

import * as express from 'express';

const app = express();

app.listen(3000, () => {
  console.log('Cron job listening on port 3000');
});

With these steps, you should have a cron job that runs every 5 minutes, updates a Firebase collection, and is set up using NodeJS, Express, and TypeScript.

A practical method for managing environment variables in microservices running on AWS ECS

Asif — Tue, 13 Dec 2022 10:19:49 +0000

There are several methods for managing environment variables in AWS ECS microservices. To store and manage your environment variables, one common method is to use AWS Systems Manager Parameter Store. This service allows you to store sensitive information, such as database passwords, in a secure and scalable way. The parameters can then be referenced in your ECS tasks or services by using the ssm parameter provider in the ECS task definition. This allows you to easily update and manage your environment variables without having to redeploy your services or update your task definitions.

Another option is to store and manage your secrets using AWS Secrets Manager. This service allows you to store and encrypt your secrets, and then use the secretsmanager parameter provider in the task definition to reference them in your ECS tasks. This can be a convenient way to manage your secrets and automatically rotate them if necessary.

Whatever method you use, it's critical to follow best practices for security and secret management when working with environment variables in ECS. This includes encrypting your secrets at all times and using IAM policies to limit access to your secrets.

Here's an illustration:

import * as express from 'express';
import { SSM } from '@aws-sdk/client-ssm';

const app = express();

// Set up AWS Systems Manager client
const ssm = new SSM({
  region: 'us-east-1'
});

// Function to get a secret from the parameter store
async function getSecret(name: string) {
  const result = await ssm.getParameter({
    Name: name,
    WithDecryption: true
  }).promise();

  return result.Parameter.Value;
}

// Function to retrieve the database password from the parameter store
// and use it to connect to the database
async function connectToDatabase() {
  // Get the database password from the parameter store
  const password = await getSecret('/database/password');

  // Connect to the database using the password
  const db = new Prisma({
    database: 'mydb',
    user: 'myuser',
    password: password,
  });
}

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(3000, () => {
  console.log('App listening on port 3000');
});

In this example, the getSecret function is used to retrieve a secret from the parameter store by its name. The connectToDatabase function uses the getSecret function to retrieve the database password from the parameter store, and then uses it to connect to the database.

You can use this approach to retrieve any secrets that you need for your application, and use them in whatever way is appropriate for your application.