ChatGPT Interview Questions | API Design Interview Questions

January 10th, 2024

ChatGPT Interviews - API Design Introduction:

I thought it could be fun to ask ChatGPT to design some coding interview questions, after which we’d then take a crack at solving them. This can hopefully be useful to you (mainly myself) as a resource to reference in the future as I’m preparing for technical interviews, or refreshing myself on the subject matter itself. In this post, we’ll talk about some common API design questions as defined by ChatGPT.

Table of Contents

1. Explain the key principles of RESTful API design.

RESTful API design is a fundamental aspect of modern web development. Some of the key principles in API design include statelessness, uniform resource identification, resource representation, and the proper use of HTTP methods. Let’s define each of these key aspects of API design.

Statelessness

  • Definition: In a stateless API, each request from a client contains all the information necessary to understand and process the request. The server does not store any client state between requests.
  • Advantages:
    • Simplifies server implementation as there’s no need to track the client’s state.
    • Enhances scalability, as server resources are not tied to individual client sessions.

Uniform Resource Identification (URI)

  • Definition: URIs uniquely identify resources and provide a consistent way to locate and access them. Well-designed URIs are essential for clarity and ease of use.
  • Best Practices:
    • Use meaningful, hierarchical paths that reflect the structure of the resources.
    • Choose consistent naming conventions for resources and avoid unnecessary complexity.
  • Example in TypeScript: 
    // Example URI for a resource
const resourceUri = "/api/resources/:id";

Resource Representation

  • Definition: Resources in an API are represented in a format, such as JSON or XML, that clients can understand. The representation includes the data, metadata, and links related to the resource.
  • Best Practices:
    • Use standardized formats like JSON for better interoperability.
    • Include only necessary data to minimize payload size and enhance performance.
  • Example in TypeScript: 
    // Example resource representation in JSON
const resource = {
  id: 1,
  name: "Example Resource",
  // Additional properties...
};

Proper Use of HTTP Methods

  • Definition: HTTP methods (GET, POST, PUT, DELETE, etc.) define the operations that can be performed on resources. Each method has a specific meaning and use case.

  • Best Practices:

    • Use GET for retrieving resources, POST for creating resources, PUT/PATCH for updating resources, and DELETE for removing resources.
    • Avoid using non-idempotent methods (like POST) for actions that should not be repeated.

  • Example in TypeScript:

    // Example route using different HTTP methods
app.get("/api/resources/:id", (req, res) => {
  // Logic for retrieving a resource
});

app.post("/api/resources", (req, res) => {
  // Logic for creating a new resource
});

app.put("/api/resources/:id", (req, res) => {
  // Logic for updating a resource
});

app.delete("/api/resources/:id", (req, res) => {
  // Logic for deleting a resource
});

In TypeScript, implementing a simple RESTful endpoint for resource retrieval could look like the following:

import express from "express";

const app = express();

// Endpoint for retrieving a resource (GET method)
app.get("/api/resource/:id", (req, res) => {
  const resourceId = req.params.id;
  // Logic to retrieve and return the resource
  res.json({ id: resourceId, data: "resourceData" });
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

2. How would you handle versioning in your API?

API versioning is essential for maintaining backward compatibility while introducing changes or enhancements. One approach is to include the version in the URL or headers. In TypeScript, you can implement versioning like this:

import express from "express";

const app = express();

// Version 1 of the API
app.get("/api/v1/resource/:id", (req, res) => {
  // Logic for version 1
});

// Version 2 of the API
app.get("/api/v2/resource/:id", (req, res) => {
  // Logic for version 2
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

This structure allows for different versions to coexist and ensures a smooth transition for clients.

3. Describe the role of HTTP status codes in API responses.

HTTP status codes play a crucial role in communicating the outcome of an API request. Understanding all status code values as well as definitions is fundamental to API design. For example, a successful response might use a 200 OK status, while a resource not found would return a 404 Not Found. Handling status codes effectively enhances the API’s usability and provides clear feedback to clients. Here’s an example in TypeScript:

import express from "express";

const app = express();

app.get("/api/resource/:id", (req, res) => {
  const resourceId = req.params.id;
  const resource = getResourceById(resourceId);

  if (resource) {
    res.status(200).json(resource); // 200 OK
  } else {
    res.status(404).json({ error: "Resource not found" }); // 404 Not Found
  }
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

4. How do you ensure security in your API design, especially against common vulnerabilities?

Securing APIs is paramount. Some common practices when securing APIs include validating input, implementing proper authentication and authorization mechanisms, protecting against SQL injection and cross-site scripting (XSS), and employing secure communication through HTTPS. In TypeScript and Node.js, using middleware like helmet can enhance security:

import express from "express";
import helmet from "helmet";

const app = express();

// Use Helmet middleware for enhanced security headers
app.use(helmet());

// Other middleware and routes...

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

5. How would you handle rate limiting and throttling in your API?

API rate limiting and throttling are crucial for preventing abuse and ensuring fair usage. Libraries like express-rate-limit in TypeScript can be used to implement rate limiting:

import express from "express";
import rateLimit from "express-rate-limit";

const app = express();

// Apply rate limiting middleware
const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests per windowMs
});

app.use(limiter);

// Other middleware and routes...

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

This ensures that clients are restricted to a certain number of requests within a specified time window.

6. How do you design pagination in API responses for large datasets?

Handling large datasets efficiently is crucial for optimal API performance. Pagination should be implemented to provide clients with manageable portions of data with reasonable latencies. In TypeScript, you can achieve pagination by using query parameters:

import express from "express";

const app = express();

// Endpoint with pagination support
app.get("/api/resources", (req, res) => {
  const page = parseInt(req.query.page as string) || 1;
  const pageSize = parseInt(req.query.pageSize as string) || 10;

  // Logic to retrieve and return paginated resources
  const paginatedResources = getResourcesPaginated(page, pageSize);
  res.json(paginatedResources);
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

7. Explain the concept of idempotency in the context of API design.

Idempotency is a crucial concept in API design, ensuring that an operation’s effect is the same, regardless of how many times it’s executed. APIs should be designed with idempotency in mind, especially for operations that can be retried without unintended side effects. In TypeScript, implementing an idempotent endpoint might look like this:

import express from "express";

const app = express();

// Idempotent endpoint
app.put("/api/resource/:id", (req, res) => {
  const resourceId = req.params.id;
  // Logic to update or create the resource
  res.status(200).json({ message: "Resource updated or created successfully" });
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

8. Discuss the importance of HATEOAS in RESTful API design.

Hypermedia as the Engine of Application State (HATEOAS) is a principle that enriches RESTful APIs by providing navigation links within API responses. It’s important in promoting discoverability and guiding clients through available actions. While TypeScript doesn’t enforce HATEOAS, including links in API responses enhances the client’s understanding of available interactions.

import express from "express";

const app = express();

// Endpoint with HATEOAS support
app.get("/api/resource/:id", (req, res) => {
  const resourceId = req.params.id;
  const resource = getResourceById(resourceId);

  if (resource) {
    // Include HATEOAS links in the response
    resource.links = [
      { rel: "self", href: `/api/resource/${resourceId}` },
      { rel: "edit", href: `/api/resource/${resourceId}/edit` },
    ];
    res.status(200).json(resource);
  } else {
    res.status(404).json({ error: "Resource not found" });
  }
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

9. How would you handle errors and exceptions in your API responses?

Proper error handling is critical for robust APIs. In TypeScript, a standardized approach to handling errors might involve creating custom error classes and using middleware:

import express from "express";

class CustomError extends Error {
  constructor(message: string, public statusCode: number) {
    super(message);
    this.name = this.constructor.name;
  }
}

const app = express();

// Error handling middleware
app.use(
  (
    err: Error,
    req: express.Request,
    res: express.Response,
    next: express.NextFunction
  ) => {
    if (err instanceof CustomError) {
      res.status(err.statusCode).json({ error: err.message });
    } else {
      // Handle other types of errors
      res.status(500).json({ error: "Internal Server Error" });
    }
  }
);

// Other routes and middleware...

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

10. What strategies would you employ to ensure backward compatibility in API changes?

Maintaining backward compatibility is crucial when evolving APIs to avoid disrupting existing clients. Strategies to ensure backward compatibility in your APIs could include versioning, introducing new features without removing existing ones, and providing clear communication through documentation. TypeScript’s static typing can aid in preventing breaking changes, and versioning strategies can help transition clients smoothly:

import express from "express";

const app = express();

// Version 1 of the API
app.get("/api/v1/resource/:id", (req, res) => {
  // Logic for version 1
});

// Version 2 of the API with additional features
app.get("/api/v2/resource/:id", (req, res) => {
  // Logic for version 2, building upon version 1
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

11. How do you approach caching strategies in API design, and what considerations are essential?

Caching is a crucial aspect of API design for optimizing performance and reducing server load. When implementing caching, it’s vital to consider factors such as cache duration, cache validation, and cache eviction policies.

// Example: Server-side caching in Express using memory cache
// Would not be horizontally scalable
import express from "express";
import morgan from "morgan";
import memoryCache from "memory-cache";

const app = express();

// Middleware for logging
app.use(morgan("dev"));

// Middleware for caching with a 5-minute expiration time
app.use((req, res, next) => {
  const key = `__express__${req.originalUrl || req.url}`;
  const cachedBody = memoryCache.get(key);

  if (cachedBody) {
    return res.send(cachedBody);
  } else {
    res.sendResponse = res.send;
    res.send = (body) => {
      memoryCache.put(key, body, 5 * 60 * 1000); // Cache duration: 5 minutes
      res.sendResponse(body);
    };
    next();
  }
});

// Your routes and other middleware...

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

12. Can you explain the role of content negotiation in API responses and how you would implement it in TypeScript?

Content negotiation involves selecting the most appropriate representation of a resource based on the client’s preferences. This is often achieved using the Accept header in HTTP requests.

// Example: Content negotiation in Express with JSON and XML support
import express from "express";

const app = express();

app.get("/api/resource/:id", (req, res) => {
  const resourceId = req.params.id;
  const resource = getResourceById(resourceId);

  if (!resource) {
    res.status(404).json({ error: "Resource not found" });
    return;
  }

  // Content negotiation based on the 'Accept' header
  const acceptHeader = req.get("Accept");
  if (acceptHeader && acceptHeader.includes("application/xml")) {
    // Respond with XML representation
    res.type("application/xml");
    res.send(jsonToXml(resource));
  } else {
    // Default to JSON representation
    res.json(resource);
  }
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

13. How would you design and implement an authentication mechanism for your API?

Implementing secure authentication is paramount in API design. Industry-standard authentication mechanisms include OAuth 2.0 or JWT, and an example is below that is written in TypeScript assuming an Express server that shows a simple JWT implementation.

// Example: JWT-based authentication in Express
import express from "express";
import jwt from "jsonwebtoken";

const app = express();

// Middleware for JWT-based authentication
const authenticateJWT = (req, res, next) => {
  const token = req.header("Authorization");

  if (!token) {
    return res.status(401).json({ error: "Unauthorized" });
  }

  jwt.verify(token, "your-secret-key", (err, user) => {
    if (err) {
      return res.status(403).json({ error: "Forbidden" });
    }

    req.user = user;
    next();
  });
};

// Protected route using authentication middleware
app.get("/api/protected-resource", authenticateJWT, (req, res) => {
  res.json({ message: "You have access to the protected resource" });
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

14. Explain the role of content compression in API responses and how you would implement it.

Content compression, often achieved using the Content-Encoding header, reduces the size of API responses, improving performance and reducing bandwidth usage. A simple example of content compression in an Express server is shown below using the compression library.

// Example: Content compression in Express using gzip
import express from "express";
import compression from "compression";

const app = express();

// Middleware for content compression
app.use(compression());

// Your routes and other middleware...

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

Considerations and Best Practices:

While content compression brings significant benefits, it’s essential to consider a few factors:

  • Client Support: Ensure that clients can decompress and handle compressed content. Most modern web browsers and HTTP clients support content compression, but it’s crucial to verify compatibility with your specific client base.

  • CPU Overhead: Compression and decompression processes consume CPU resources. Consider the server’s capacity and ensure that the overhead introduced by compression does not negatively impact overall system performance.

  • Dynamic vs. Static Content: Content compression is particularly effective for static content that doesn’t change frequently. For dynamic content, especially when generated on the fly, the benefits might be less pronounced.

15. How would you design and implement a webhook system in your API for real-time notifications?

Webhooks enable real-time communication between systems by allowing one system to notify another about events. See a simple example of webhook authentication in an Express server below.

// Example: Webhook system in Express
import express from "express";
import crypto from "crypto";

const app = express();

// Secret key for webhook authentication
const webhookSecret = "your-webhook-secret";

// Endpoint for receiving webhook events
app.post("/api/webhook", (req, res) => {
  const payload = JSON.stringify(req.body);
  const signature = req.get("X-Hub-Signature-256");

  // Verify webhook payload using the secret key
  const hash = crypto
    .createHmac("sha256", webhookSecret)
    .update(payload)
    .digest("hex");
  if (hash === signature) {
    // Webhook payload is valid
    // Process the event...
    res.status(200).send("Webhook received successfully");
  } else {
    // Invalid webhook payload
    res.status(403).send("Invalid webhook signature");
  }
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

Key Components of Webhook Design:

Event Identification: Begin by identifying the events for which you want to provide notifications. These events could include data updates, user actions, or any other significant occurrences within your system.

Webhook Registration: Implement a mechanism for clients to register or subscribe to specific events. This involves providing an endpoint (URL) where the server can send notifications.

Event Payload: Define the structure of the payload that will be sent in the webhook notification. This payload should include relevant information about the event, allowing the receiving system to understand and process it effectively.

Security Measures: Implement security measures to ensure the integrity and authenticity of webhook notifications. This may involve using secure channels (HTTPS), authentication mechanisms, and possibly signature verification to prevent unauthorized access and tampering.

16. How do you approach API documentation, and what tools or formats do you prefer for documenting APIs?

Documentation is critical for the adoption and understanding of APIs. Utilizing tools like Swagger/OpenAPI or API Blueprint can streamline the documentation process and ensure consistency.

// Example: Swagger/OpenAPI documentation in Express
import express from "express";
import swaggerJsdoc from "swagger-jsdoc";
import swaggerUi from "swagger-ui-express";

const app = express();

// Swagger/OpenAPI options
const options = {
  definition: {
    openapi: "3.0.0",
    info: {
      title: "Your API",
      version: "1.0.0",
      description: "API documentation using Swagger/OpenAPI",
    },
  },
  apis: ["./routes/*.js"], // Specify your route files
};

const specs = swaggerJsdoc(options);

// Serve Swagger UI at /api-docs endpoint
app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(specs));

// Your routes and other middleware...

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

17. Can you discuss the pros and cons of GraphQL compared to REST, and in what scenarios would you choose one over the other?

GraphQL is an alternative to REST for designing APIs, allowing clients to request exactly the data they need.

Pros and Cons of GraphQL Compared to REST:

1. Flexibility and Efficiency:

  • GraphQL (Pros): One of the primary advantages of GraphQL is its flexibility. Clients can request exactly the data they need, avoiding over-fetching or under-fetching of data. This reduces the amount of data transferred over the network, leading to more efficient API responses.
// Example: GraphQL query in TypeScript using Apollo Client
const GET_USER_DETAILS = gql`
  query GetUserDetails($userId: ID!) {
    user(id: $userId) {
      id
      name
      email
      posts {
        title
        content
      }
    }
  }
`;
  • REST (Cons): REST APIs often suffer from over-fetching or under-fetching issues. Clients might receive more data than necessary or need to make multiple requests to gather all the required data.

2. Single Request for Multiple Resources:

  • GraphQL (Pros): GraphQL allows clients to request multiple resources in a single query, reducing the number of network requests. This can significantly improve performance, especially in scenarios where bandwidth is limited.
// Example: GraphQL query for multiple resources
const GET_USER_AND_POSTS = gql`
  query GetUserAndPosts($userId: ID!) {
    user(id: $userId) {
      id
      name
      email
    }
    posts(userId: $userId) {
      title
      content
    }
  }
`;
  • REST (Cons): In REST, obtaining related resources often requires multiple requests, leading to potential latency issues.

3. Discoverability and Standardization:

  • GraphQL (Cons): While GraphQL provides strong typing and introspection, the lack of a standardized approach for documentation and discoverability can be a challenge. Developers might need additional tools like GraphQL Playground or GraphiQL for exploration.
// Example: GraphQL schema definition
type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post!]!
}

type Post {
  title: String!
  content: String!
}
  • REST (Pros): RESTful APIs often benefit from standardized documentation tools like Swagger or OpenAPI, providing a clear and standardized way for clients to understand available resources and actions.

4. Backend Control and Security:

  • GraphQL (Pros): GraphQL enables clients to request specific data, but this can lead to potential security concerns if not handled correctly. However, GraphQL’s resolver functions provide a way to control data access and ensure security.
// Example: GraphQL resolver with authorization check
const resolvers = {
  Query: {
    user: (_, { id }, context) => {
      // Check user's authorization before returning data
      if (context.currentUser.id !== id) {
        throw new Error("Unauthorized access");
      }
      // Return user data
      return getUserById(id);
    },
  },
};
  • REST (Cons): RESTful APIs often have a more standardized approach to security through the use of HTTP methods and status codes. However, over time, REST APIs may accumulate multiple endpoints with varying security measures.

Choosing Between GraphQL and REST:

The choice between GraphQL and REST depends on several factors:

  • Nature of the Project: For projects with dynamic requirements or evolving data structures, GraphQL’s flexibility may be advantageous. REST might be preferred for projects with stable requirements and well-defined resources.

  • Client Requirements: If clients have specific data fetching needs and require minimal payload, GraphQL might be more suitable. REST may be preferred for scenarios where a standardized approach is essential.

  • Tooling and Ecosystem: Consider the existing tools and ecosystem of your project. If standardized documentation and discoverability are crucial, REST may have an edge.

Below is a simple example of a GraphQL server that is implemented in Express.

// Example: GraphQL implementation using Apollo Server in Express
import express from "express";
import { ApolloServer, gql } from "apollo-server-express";

const app = express();

// GraphQL schema definition
const typeDefs = gql`
  type Query {
    hello: String
  }
`;

// GraphQL resolver
const resolvers = {
  Query: {
    hello: () => "Hello, GraphQL!",
  },
};

// Apollo Server setup
const server = new ApolloServer({ typeDefs, resolvers });

// Apply Apollo Server middleware
server.applyMiddleware({ app });

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

18. Discuss the considerations and trade-offs when choosing between synchronous and asynchronous communication in API design.

Choosing between synchronous and asynchronous communication is a critical decision that impacts system performance and responsiveness.

Key Components of Asynchronous Design:

1. Event-Driven Architecture:

  • Overview: Asynchronous systems often follow an event-driven architecture, where components communicate through events or messages. Events trigger actions, allowing the system to respond to changes or external stimuli in a non-blocking manner.
// Example: Event-driven architecture in Node.js using EventEmitter
const EventEmitter = require("events");

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on("event", () => {
  console.log("Event received");
});

// Trigger the event asynchronously
setImmediate(() => {
  myEmitter.emit("event");
});

2. Message Queues:

  • Overview: Message queues enable decoupling between components by allowing them to communicate through messages. This is particularly useful for handling tasks asynchronously, ensuring that tasks can be processed independently without directly blocking the sender.
// Example: Using a message queue library (e.g., RabbitMQ) in a Node.js application
const amqp = require("amqplib");

async function sendMessage() {
  const connection = await amqp.connect("amqp://localhost");
  const channel = await connection.createChannel();

  const queue = "example_queue";
  const message = "Hello, world!";

  channel.assertQueue(queue, { durable: false });
  channel.sendToQueue(queue, Buffer.from(message));

  console.log("Message sent");
}

sendMessage();

3. Async/Await in Functions:

  • Overview: The use of asynchronous functions and the async/await syntax is prevalent in languages that support it. This allows asynchronous code to be written in a more synchronous style, making it easier to reason about and maintain.
// Example: Async/await in TypeScript
async function fetchData() {
  const response = await fetch("https://api.example.com/data");
  const data = await response.json();
  return data;
}

// Call the asynchronous function
fetchData().then((result) => console.log(result));

Best Practices in Asynchronous Design:

1. Error Handling:

  • Overview: Proper error handling is crucial in asynchronous systems. Unhandled errors in asynchronous operations can lead to unpredictable behavior and potential system instability.
// Example: Error handling in async/await
async function fetchData() {
  try {
    const response = await fetch("https://api.example.com/data");
    const data = await response.json();
    return data;
  } catch (error) {
    console.error("Error fetching data:", error);
    throw error;
  }
}

2. Backpressure and Throttling:

  • Overview: Implement mechanisms for handling backpressure, especially in scenarios where asynchronous tasks might overload downstream components. Throttling or rate limiting can help regulate the flow of incoming requests.

3. Concurrency Control:

  • Overview: Manage concurrency to avoid potential resource contention. Techniques such as limiting the number of concurrent operations or using thread pools can prevent overwhelming the system.

Considerations for Scalability:

Asynchronous design plays a critical role in building scalable systems. Consider the following aspects:

  • Parallelism: Leverage parallel processing to execute multiple tasks simultaneously, enhancing overall system throughput.

  • Resource Management: Efficiently manage resources, such as connections to databases or external services, to prevent bottlenecks and ensure optimal performance.

  • Load Balancing: Distribute asynchronous tasks across multiple servers or worker processes to balance the load and maximize resource utilization.

Below you’ll find a final example of a simple message queue architecture implemented in Express.

// Example: Asynchronous communication using message queues in Express
import express from "express";
import amqp from "amqplib";

const app = express();

// Example route handling asynchronous communication
app.post("/api/async-process", async (req, res) => {
  // Process the synchronous part of the request...

  // Asynchronously publish a message to a message queue
  const message = { data: "Async data" };
  const connection = await amqp.connect("amqp://localhost");
  const channel = await connection.createChannel();
  channel.sendToQueue("async_queue", Buffer.from(JSON.stringify(message)));

  // Respond to the client
  res.json({ message: "Request received, processing asynchronously" });
});

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

19. How would you handle cross-origin resource sharing (CORS) in your API, and what security implications should be considered?

Handling CORS is essential to allow or restrict access to resources from different origins. Below is an example of using CORS headers to allow access to an Express server.

// Example: CORS handling in Express
import express from "express";

const app = express();

// Middleware for CORS handling
app.use((req, res, next) => {
  res.header("Access-Control-Allow-Origin", "*"); // Allow any origin (replace '*' with specific origins in production)
  res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
  res.header("Access-Control-Allow-Headers", "Content-Type, Authorization");

  // Handling preflight requests
  if (req.method === "OPTIONS") {
    res.sendStatus(200);
  } else {
    next();
  }
});

// Your routes and other middleware...

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

20. How would you optimize the performance of your API, especially in terms of response time and resource utilization?

Optimizing API performance is crucial for providing a seamless user experience. To improve the performance of an API’s response time, techniques such as such as caching, efficient database queries, and load balancing can be explored. Additionally, monitoring and profiling tools can be employed to identify and address performance bottlenecks, with an example of performance monitoring in Express below.

// Example: API performance optimization in Express
import express from "express";
import morgan from "morgan";
import responseTime from "response-time";

const app = express();

// Middleware for logging response times
app.use(morgan("dev"));

// Middleware for monitoring response times
app.use(responseTime());

// Your routes and other middleware...

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});