✅ Fix high memory usage

[NicolasMahe]

Hi,

I'm investigating an issue with unexpectedly high memory consumption in a project deployed on Firebase Functions.

As a baseline, the following minimal Express setup behaves as expected and uses little memory:

import type { Response } from "express";
import express from "express";
import type { Request } from "firebase-functions/https";

let app: express.Application | null = null;

function initializeApp(): express.Application {
  if (app) return app;

  app = express();

  app.get("/ping", (_, res) => res.json({ message: "pong" }));

  return app;
}

export const handler = (req: Request, res: Response) => {
  const expressApp = initializeApp();
  expressApp(req, res);
};

However, when I deploy the following version with a single express-zod-api endpoint the memory usage increases by roughly 70 MB:

import type { Response } from "express";
import express from "express";
import { attachRouting, createConfig, defaultEndpointsFactory } from "express-zod-api";
import { logger } from "firebase-functions";
import type { Request } from "firebase-functions/https";
import { z } from "zod";

let app: express.Application | null = null;

function initializeApp(): express.Application {
  if (app) return app;

  app = express();

  const config = createConfig({
    app,
    logger: logger,
    cors: true,
    startupLogo: false,
  });
  attachRouting(config, {
    hello: defaultEndpointsFactory.build({
      method: "get",
      output: z.object({
        response: z.string(),
      }),
      handler: async () => {
        return { response: "Hello" };
      },
    }),
  });

  app.get("/ping", (_, res) => res.json({ message: "pong" }));

  return app;
}

export const handler = (req: Request, res: Response) => {
  const expressApp = initializeApp();
  expressApp(req, res);
};

Is this memory increase expected when using express-zod-api?
Do you have any recommendations to help reduce the library’s memory footprint in this context?

Thanks!

[RobinTail]

Hello @NicolasMahe

I'm investigating an issue with unexpectedly high memory consumption
when I deploy the following version with a single express-zod-api endpoint the memory usage increases

This is a very interesting and complicated type of investigations.
I must say, that from the given code samples I see that you're comparing the applications having not only express-zod-api added to the runtime, but also a cutom logger instance, and several zod schemas that do obviously take some memory, which makes this comparison not quite clean. First sample literally has no IO validation at all.
However, the entities you import from express-zod-api (2 functions and a class instance holding methods and 2 Zod schemas), do also consume some memory, which is in general a normal thing.

I can only recommend you to seek for a way to exclude factors beyond the scope of your investigation:

• other libraries;
• different environments (local vs. deployed);

as well as to use some tools, such as Node.js inspector, to make snapshots for figuring out the actual cause.

Once you find it out — please let me know.

[NicolasMahe]

Hi @RobinTail,

I experimented with the Node.js inspector and found some interesting results regarding memory usage.

Using a very simple express-zod-api app (similar to my previous message), Activity Monitor reports ~177 MB of memory usage and the following heap snapshot:

Most of the memory is attributed to the string and compiled code sections.

Looking closer at the string section, a large portion appears to come from TypeScript-related source code:

Similarly, the compiled code section shows that TypeScript accounts for most of the usage:

I then investigated why TypeScript is being imported in such a simple app and found that it is pulled in by the following files:

• express-zod-api/src/integration-base.ts
• express-zod-api/src/integration.ts
• express-zod-api/src/typescript-api.ts
• express-zod-api/src/zts-helpers.ts
• express-zod-api/src/zts.ts

To evaluate the impact, I removed these files and built a custom version of express-zod-api. The build still worked after removing just two exports (Integration and Producer) from index.ts, which my app does not use.

With this change, memory usage dropped to ~94 MB (–83 MB, roughly matching the difference I observe on Firebase Functions). I then took another heap snapshot:

Both the string and compiled code sections are significantly reduced, with no remaining references to TypeScript files.

Conclusion

It appears that most of the memory overhead comes from importing TypeScript, which is only required for the Integration class. (Producer / zts-helpers import TypeScript as a type, so they should not have any runtime impact after build.)

Simply moving the Integration export to a dedicated entry point (e.g. express-zod-api/integration) could already reduce the memory footprint.
This could potentially be taken further by extracting it into a separate package and removing the dependency on TypeScript from express-zod-api itself:

express-zod-api/express-zod-api/package.json

Lines 51 to 61 in 4c0d8bd

	"peerDependencies": {
	"@types/compression": "^1.7.5",
	"@types/express": "^5.0.0",
	"@types/express-fileupload": "^1.5.0",
	"@types/http-errors": "^2.0.2",
	"compression": "^1.8.0",
	"express": "^5.1.0",
	"express-fileupload": "^1.5.0",
	"http-errors": "^2.0.1",
	"typescript": "^5.1.3",
	"zod": "catalog:peer"

Let me know what you think — happy to help test or prototype a change.

[NicolasMahe]

Great news!
I’ll try to test this today, but more likely on Monday or Tuesday.
Thanks for the quick update!

[NicolasMahe]

Hi @RobinTail,

I finally had time to test this.

The beta version does improve memory usage a bit, but not completely.

When running the Node.js inspector, I now see only one TypeScript entry in the string section instead of two previously. However, TypeScript still appears in the compiled code section, which suggests it is still being imported somewhere.

I also deployed the beta version to my Firebase project and observed similar results: a small reduction in memory usage, but not as large as expected.

For comparison, I ran each version multiple times locally and observed the following memory usage:

• only express: ~56 MB
• express-zod-api v26.0.0: ~164 MB
• express-zod-api v26.1.0-beta.1: ~162 MB
• express-zod-api v26.0.0 without export { Integration } from "./integration";: ~94 MB

For the last case, I only removed export { Integration } from "./integration"; from index.ts, while still keeping
export type { Producer } from "./zts-helpers";. This really suggests that TypeScript is still being fully imported somewhere else.

After further investigation of PR #3139, I found that the filezts.ts is still importing TypeScript. To confirm this was the last remaining place, I replaced its import with import type ts from "typescript"; and hardcoded isTypeLiteralNode and SyntaxKind (since those two are not types) so the build would still work.

After rerunning my tests and the Node.js inspector, memory usage dropped to the expected level (~96 MB), and there were no more references to TypeScript in the inspector 🎊

I left a comment on PR #3139 pointing out this last TypeScript import.
Hopefully, removing it will fully address the memory usage issue.

[RobinTail]

Yeah, lost the track of that import. Thank you, @NicolasMahe
I published another version: 26.1.0-beta.2.
Please try again

[NicolasMahe]

Hi @RobinTail,

The latest update fixes the high memory usage 🎊

I no longer see any TypeScript related entries in the Node.js inspector, and the memory footprint now even seems slightly lower than expected, both locally and on Firebase. The Integration generator is also still working as expected.

Thanks a lot for the fixes! 🙂

[RobinTail]

🚀 v26.1.0 released
Thank you for the contribution, @NicolasMahe