Do Google Cloud Platform HTTP Functions Support Route Parameters?

You could try modofun: https://modofun.js.org

Which is a router for multiple operations based on the request path, and also supports automatic parameter parsing from the path.

It parses the URL path into an operation name and a list of parameters which are populated into req.params, same as with Express when using regex. So you could do something like this:

var modofun = require('modofun')

exports.bookstore = modofun(
  {
    /**
     * /users/:userId/:bookId
     */
    users: (req, res) => {
      var [userId, bookId] = req.params
      // ...
      res.json(data)
    }
  },
  { mode: 'reqres' }
)

Or, you can also have the parameters expanded into function arguments and work with pure functions, like this:

var modofun = require('modofun')

exports.bookstore = modofun(
  {
    /**
     * /users/:userId/:bookId
     */
    users: (userId, bookId) => {
      // ...
      return data
    }
  },
  { mode: 'function' }
)

I made it for a Google Cloud Functions deployment I have in production, mostly because I don't need the large dependency trail from Express, and I wanted something more lightweight.

But remember that you can also just use an Express together with Google Cloud Functions. Nothing stops you from creating an Express app with the usual route matching rules and then passing that as the export for your GCloud Function.

Hope that helps.

First Create a Handler function,

function bookIdHandler(req,res){
    let bookId= req.params.bookId;

    //your code goes here
}

You can just pass an Express App object to cloud function routes

const express = require('express');

const app = express();

app.get('users/:userId/:bookId', bookIdHandler);
//++ any other express endpoints


// Expose Express API as a single Cloud Function:
exports.widgets = functions.https.onRequest(app);

Ref:How its mentioned in firebase docs

If you don't want to pass data in the body, you can always put it into a query parameter of the url. Like:

http://yourGoogleProject.cloudfunctions.net/users?userid={userId}&bookId={bookid}

And in the cloud function you simply access the query parameter from the req object, like:

exports.users = (req, res) => {
  res.status(200).send(`Hello from user:  + $(req.query.userid) your bookId: $(req.query.bookid)`);
  }

Here is an example of how to implement a file-based router (similar to Next.js API router), that works with Cloud Functions and URL parameters.

Assuming you want to handle a bunch of API endpoints looking as follows:

  GET https://example.com/api/v1/posts
 POST https://example.com/api/v1/posts
  GET https://example.com/api/v1/posts/123
PATCH https://example.com/api/v1/posts/123

Create a new file for each URL route:

/v1/posts/[id].ts
/v1/posts/index.ts
/v1/authors/[username].ts
/v1/authors/index.ts

Where each route matches the following signature (example):

import { HttpFunction } from "@google-cloud/functions-framework";

/**
 * Fetches a post by ID.
 *
 * @example GET /api/v1/posts/1
 */
export const GET: HttpFunction = async (req, res) => {
  const url = `https://jsonplaceholder.typicode.com/posts/${req.params.id}`;
  const fetchRes = await fetch(url);
  const post = await fetchRes.json();
  res.send(post);
};

/**
 * Updates an existing post.
 *
 * @example PATCH /api/v1/posts/1
 */
export const PATCH: HttpFunction = async (req, res) => {
  throw new Error("Not implemented");
};

At the top level, in the entry point, just load the list of files from the "routes" folder, e.g.

// https://vitejs.dev/guide/features.html#glob-import
const routeFiles = import.meta.glob(["./v1/**/*.ts", "!./**/*.test.ts"]);

Append a RegExp for each route derived from the filename using path-to-regexp, then iterate through the files and execute the matching handler function:

import { HttpFunction, http } from "@google-cloud/functions-framework";
import { HttpError, NotFound } from "http-errors";
import { match } from "path-to-regexp";

// https://vitejs.dev/guide/features.html#glob-import
const routeFiles = import.meta.glob(["./v1/**/*.ts", "!./**/*.test.ts"]);
const routes = Object.entries(routeFiles).map(...);

http("api", async (req, res) => {
  try {
    for await (const route of routes) {
      const match = route.match(req.path);

      if (match) {
        Object.assign(req.params, match.params);
        const module = await route.import();
        await module?.[req.method]?.(req, res);
        if (res.headersSent) return;
      }
    }

    throw new NotFound();
  } catch (err) {
    // TODO: Send an error response
  }
});

A unit test for each route would look similar to this (e.g. v1/posts/[id].test.ts):

import { getTestServer } from "@google-cloud/functions-framework/testing";
import supertest from "supertest";
import { expect, test } from "vitest";
import { functionName } from "../../index";

test("GET /api/v1/posts/1", async () => {
  const server = getTestServer(functionName);
  const res = await supertest(server)
    .get("/api/v1/posts/1")
    .set("Accept", "application/json");

  expect({ statusCode: res.statusCode body: res.body })
    .toEqual({/* ... */});
});

https://github.com/koistya/cloud-functions-routing

Use Express API

npm install --save express body-parser

In index.ts make the following changes:

//import library
import * as express from 'express';
//init Express server
const app = express();
//change the Google function to receive an Express server object
export const myFunc = functions.https.onRequest(app);
//create your endpoints specifying HTTP Verbs
app.get('/isbn/:isbn', async (request, response) => {
   //...
   //get route parameter
   const isbn = request.params.isbn;
   //...