How can I integrate Octokit into a CommonJS Firebase Functions project without switching to Node16?

Below is one approach to work around the issue while staying in a CommonJS Firebase functions project.

Why This Happens
The error
  Error [ERR_REQUIRE_ESM]: require() of ES Module …
occurs because the octokit package (or its sub‑package like "@octokit/app") is distributed as an ES module. When you try to import it with a static ES import (or convert it via CommonJS require), Node (under a CommonJS configuration) won’t allow it.

Possible Solutions

1. Use Dynamic Imports in Your CommonJS Code
   You can load an ESM module inside a CommonJS file using the dynamic import function. For example:

   JAVASCRIPTCopied
   // In your Firebase function (CommonJS)
   exports.myFunction = async (req, res) => {
     // Dynamically import the module (returns a promise)
     const { App } = await import("@octokit/app");
     
     // Now you can use App as needed
     const myApp = new App({ /* configuration */ });
     
     // ... do work with myApp
     res.send("Function executed");
   };

   This avoids the need to change your module configuration. However, remember that dynamic imports must be awaited in an async context.

2. Bundle with a Tool That Supports ESM in a CommonJS Output
   Another route is to use a bundler (like webpack or Rollup) which can transpile and bundle the octokit ES modules into a CommonJS format. This means your codebase can remain in CommonJS while the bundler converts the imports:

   • Configure your bundler to output in CommonJS.
   • Your source code can use standard ES imports.
   • The bundled output will use require() appropriately.

   This option adds a build step but can keep your original coding style.

3. Switch to an ESM Environment
   Firebase Functions now supports Node.js 16 and later as an opt-in runtime. By setting "type": "module" in your package.json (or using an .mjs filename), you can write standard ES module code. For example:

   JSONCopied
   {
     "engines": { "node": "16" },
     "type": "module",
     "dependencies": {
       "@octokit/app": "x.y.z"
     }
   }

   And then in your function file:

   JAVASCRIPTCopied
   import { App } from "@octokit/app";
   
   export const myFunction = async (req, res) => {
     const myApp = new App({ /* configuration */ });
     // ... work with myApp
     res.send("Function executed");
   };

   This is the most seamless approach with octokit, but you mentioned you prefer to remain in CommonJS.

Summary

If you want to stick with CommonJS without switching to a Node 16 ESM setup, the dynamic import approach or bundling (to downgrade the ESM module into CommonJS) are your best options. The dynamic import method is the simplest to implement if you can adjust your function code to be async.

Choose the method that best fits your project needs.