Try Typescript

package.json

@@ -1,7 +1,7 @@
 {
   "name": "acme-node",
   "type": "module",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Sample Application with developer friendly boilerplate",
   "scripts": {
     "start": "node ./src/index.js",
@@ -14,6 +14,7 @@
     "@grpc/grpc-js": "^1.12.4",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/auto-instrumentations-node": "^0.55.0",
+    "@types/express-serve-static-core": "^5.0.3",
     "express": "^4.21.1"
   },
   "devDependencies": {

src/app.js

@@ -2,7 +2,6 @@ import express from "express";
 
 import routeHandler from "./routes/index.js";
 import { loggingMiddleware } from "./middleware/loggingMiddleware.js";
-// import { baggageExtractorMiddleware } from "./middleware/baggageExtractorMiddleware.js";
 import { notFoundHandler } from "./middleware/notFoundHandler.js";
 import { errorHandler } from "./middleware/errorHandler.js";
 
@@ -12,7 +11,6 @@ const app = express();
 const stack = [
   express.json(),
   loggingMiddleware,
-  // baggageExtractorMiddleware,
   routeHandler,
   notFoundHandler,
   errorHandler,

src_ts/app.ts

@@ -0,0 +1,23 @@
+import express from "express";
+import { RequestHandler, Application, Express } from "express-serve-static-core";
+
+import routeHandler from "./routes/index.ts";
+import { loggingMiddleware } from "./middleware/loggingMiddleware.ts";
+import { notFoundHandler } from "./middleware/notFoundHandler.ts";
+import { errorHandler } from "./middleware/errorHandler.ts";
+
+const app: Express = express();
+
+// Middleware array, including primary routes
+const stack: RequestHandler[] = [
+  express.json(),
+  loggingMiddleware,
+  routeHandler,
+  notFoundHandler,
+  errorHandler,
+];
+
+// Attach each middleware in the stack to the app
+stack.forEach((middleware: RequestHandler) => app.use(middleware));
+
+export default app;

src_ts/clients/greetingClient.ts

@@ -0,0 +1,38 @@
+// Converted to TypeScript - Add meaningful types below
+import grpc from "@grpc/grpc-js";
+import protoLoader from "@grpc/proto-loader";
+
+import { protoLoaderOptions } from "./options.js";
+import { metadataInterceptor } from "../middleware/metadataInterceptor.js";
+
+const protoPath = "./proto/com/acme/schema/v1/greeting.proto";
+const packageDefinition = protoLoader.loadSync(protoPath, protoLoaderOptions);
+const proto = grpc.loadPackageDefinition(packageDefinition);
+const serviceURL = process.env.GREETING_SERVICE_URL;
+const { GreetingService, Language } = proto.com.acme.schema.v1;
+
+const client = new GreetingService(
+  serviceURL,
+  grpc.credentials.createInsecure(),
+  {
+    interceptors: [metadataInterceptor],
+  }
+);
+
+export const fetchGreeting = async (acceptedLanguages): any => {
+  return new Promise((resolve, reject): any => {
+    const languageEnum = Language.type.value.reduce((acc, item): any => {
+      acc[item.name] = item.number;
+      return acc;
+    }, {});
+    const preferredLanguage = acceptedLanguages.find((lang) => !!languageEnum[lang]);
+    const language = languageEnum[preferredLanguage] || Language.UNKNOWN;
+
+    client.Fetch({ language }, (error, response): any => {
+      if (error) {
+        return reject(error);
+      }
+      resolve(response);
+    });
+  });
+};

src_ts/clients/options.ts

@@ -0,0 +1,8 @@
+// Converted to TypeScript - Add meaningful types below
+export const protoLoaderOptions = {
+  keepCase: true,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true,
+};

src_ts/clients/personClient.ts

@@ -0,0 +1,31 @@
+// Converted to TypeScript - Add meaningful types below
+import grpc from "@grpc/grpc-js";
+import protoLoader from "@grpc/proto-loader";
+
+import { protoLoaderOptions } from "./options.js";
+import { metadataInterceptor } from "../middleware/metadataInterceptor.js";
+
+const protoPath = "./proto/com/acme/schema/v1/person.proto";
+const packageDefinition = protoLoader.loadSync(protoPath, protoLoaderOptions);
+const proto = grpc.loadPackageDefinition(packageDefinition);
+const serviceURL = process.env.PERSON_SERVICE_URL;
+const { PersonService } = proto.com.acme.schema.v1;
+
+const client = new PersonService(
+  serviceURL,
+  grpc.credentials.createInsecure(),
+  {
+    interceptors: [metadataInterceptor],
+  }
+);
+
+export const fetchPerson = async (uuid): any => {
+  return new Promise((resolve, reject): any => {
+    client.Fetch({ uuid }, (error, response): any => {
+      if (error) {
+        return reject(error);
+      }
+      resolve(response);
+    });
+  });
+};

src_ts/controllers/v1/errorController.ts

@@ -0,0 +1,7 @@
+import { Request, Response, NextFunction } from "express-serve-static-core"
+
+export const simulateError = (req: Request, res: Response, next: NextFunction): void => {
+  const error = new Error("Test error");
+
+  next(error);
+};

src_ts/controllers/v1/greetingController.ts

@@ -0,0 +1,28 @@
+import { Request, Response, NextFunction } from "express-serve-static-core"
+
+import { fetchGreeting } from "../../clients/greetingClient.ts";
+import { fetchPerson } from "../../clients/personClient.ts";
+
+export const greet = async (req: Request, res: Response, next: NextFunction): Promise<void> => {
+  try {
+    let acceptedLanguages = req.headers["accept-language"]?.split(",") || [];
+    acceptedLanguages = acceptedLanguages.map((lang) => lang.split(";")[0].trim().toUpperCase().replace(/-/g, "_")); // Normalize languages
+
+    const id = req.query.personID || req.params.personID;
+
+    const [greetingResponse, personResponse] = await Promise.all([
+      fetchGreeting(acceptedLanguages),
+      fetchPerson(id),
+    ]);
+
+    res.status(200).json({
+      data: {
+        language: greetingResponse.language,
+        greeting: greetingResponse.greeting,
+        audience: personResponse.name
+      },
+    });
+  } catch (error) {
+    next(error);
+  }
+};

src_ts/index.ts

@@ -0,0 +1,10 @@
+// Converted to TypeScript - Add meaningful types below
+import { LOG_LEVEL } from "./lib/log.ts";
+import app from "./app.ts";
+
+const PORT = process.env.PORT || 8080;
+
+app.listen(PORT, (): any => {
+  console.info(`Log level is set to ${LOG_LEVEL}`);
+  console.info(`Server is running on port ${PORT}`);
+});

src_ts/lib/log.ts

@@ -0,0 +1,24 @@
+enum Levels {
+  debug = 0,
+  info = 1,
+  warn = 2,
+  error = 3,
+}
+
+const levels = Levels;
+
+export const LOG_LEVEL = process.env.LOG_LEVEL || Object.keys(levels)[levels.info];
+
+const currentLevel = parseInt(levels[LOG_LEVEL.toLowerCase()]);
+
+if (currentLevel > levels.debug) {
+  console.debug = (): any => {};
+}
+
+if (currentLevel > levels.info) {
+  console.info = (): any => {};
+}
+
+if (currentLevel > levels.warn) {
+  console.warn = (): any => {};
+}

src_ts/middleware/errorHandler.ts

@@ -0,0 +1,5 @@
+// Converted to TypeScript - Add meaningful types below
+export const errorHandler = (err, req, res): any => {
+  console.error(err.stack);
+  res.status(500).send("Something went wrong!");
+};

src_ts/middleware/loggingMiddleware.ts

@@ -0,0 +1,34 @@
+// Converted to TypeScript - Add meaningful types below
+export const loggingMiddleware = (req, res, next): any => {
+  const start = Date.now();
+
+  const base = {
+    timestamp: new Date().toISOString(),
+    method: req.method,
+    path: `${req.baseUrl}${req.path}`,
+    params: req.query || req.params,
+  };
+
+  // Hook into the response lifecycle to log when it finishes
+  res.on("finish", (): any => {
+    const duration = Date.now() - start;
+    const log = {
+      status: res.statusCode,
+      duration: `${duration}ms`,
+    };
+    console.info(JSON.stringify({ ...base, ...log }));
+  });
+
+  // Hook into the response lifecycle to log errors
+  res.on("error", (err): any => {
+    const duration = Date.now() - start;
+    const log = {
+      status: res.statusCode || 500,
+      duration: `${duration}ms`,
+      error: err.message,
+    };
+    console.error(JSON.stringify({ ...base, ...log }));
+  });
+
+  next();
+};

src_ts/middleware/metadataInterceptor.ts

@@ -0,0 +1,21 @@
+// Converted to TypeScript - Add meaningful types below
+import grpc from "@grpc/grpc-js";
+import { context, propagation } from "@opentelemetry/api";
+
+export const metadataInterceptor = (options, nextCall): any => {
+  return new grpc.InterceptingCall(nextCall(options), {
+    start(metadata, listener, next) {
+      const currentContext = context.active();
+      const baggage = propagation.getBaggage(currentContext);
+
+      if (baggage) {
+        const entries = baggage.getAllEntries();
+        const baggageString = entries.map(([key, value]): any => `${key}=${value.value}`): any.join(","): any;
+
+        metadata.set("baggage", baggageString);
+      }
+
+      next(metadata, listener);
+    },
+  });
+};

src_ts/middleware/notFoundHandler.ts

@@ -0,0 +1,4 @@
+// Converted to TypeScript - Add meaningful types below
+export const notFoundHandler = (req, res): any => {
+  res.status(404).send("Route not found");
+};

src_ts/routes/index.ts

@@ -0,0 +1,11 @@
+// Converted to TypeScript - Add meaningful types below
+import { Router } from "express";
+
+import v1Routes from "./v1/index.js";
+
+const router = Router();
+
+// Mount versioned routes
+router.use("/api/v1", v1Routes);
+
+export default router;

src_ts/routes/v1/errorRoutes.ts

@@ -0,0 +1,10 @@
+// Converted to TypeScript - Add meaningful types below
+import { Router } from "express";
+
+import { simulateError } from "../../controllers/v1/errorController.js";
+
+const router = Router();
+
+router.get("/boom", simulateError);
+
+export default router;

src_ts/routes/v1/greetingRoutes.ts

@@ -0,0 +1,11 @@
+import { Router as r } from "express";
+import { Router, RequestHandler } from "express-serve-static-core"
+
+import { greet } from "../../controllers/v1/greetingController.js";
+
+const router: Router = r();
+const greetHandler: RequestHandler = greet;
+
+router.get("/hello", greetHandler);
+
+export default router;

src_ts/routes/v1/index.ts

@@ -0,0 +1,13 @@
+// Converted to TypeScript - Add meaningful types below
+import { Router } from "express";
+
+import greetingRoutes from "./greetingRoutes.js";
+import errorRoutes from "./errorRoutes.js";
+
+const router = Router();
+
+// Mount routes
+router.use(greetingRoutes);
+router.use(errorRoutes);
+
+export default router;