backend-manager 4.2.25 → 5.0.1

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(rg:*)"
+    ],
+    "deny": []
+  }
+}

package/CHANGELOG.md

@@ -15,6 +15,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - `Security` in case of vulnerabilities.
 
 ---#
+# [5.0.0] - 2025-07-10
+### ⚠️ BREAKING
+- `Manager.init()` no longer wraps the initializeApp() in `try/catch` block.
+- `Settings()` API tries to look for a method-specific file first (e.g., `name/get.js`, `name/post.js`, etc.) before falling back to `name/index.js`. This allows for more modular and organized code structure. Also, `name.js` is no longer valid, we now look for `name/index.js` this is to make it consistent with the `Middleware()` API.
+- `Middleware()` API now tries to load method-specific files (e.g., `name/get.js`, `name/post.js`, etc.) before falling back to `name/index.js`.
+- `ai.request()` no longer accepts `options.message.images`. Use `options.message.attachments` instead.
+
 # [4.2.22] - 2024-12-19
 ### Changed
 - `Manager.install()` now automatically binds the fn with the proper `this` context (this may be breaking).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "4.2.25",
+  "version": "5.0.1",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {
@@ -11,8 +11,9 @@
     "_test": "npm run prepare && ./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
     "test": "./node_modules/mocha/bin/mocha test/ --recursive --timeout=10000",
     "test:usage": "./node_modules/mocha/bin/mocha test/usage.js --timeout=10000",
-    "test:payment-resolver": "./node_modules/mocha/bin/mocha test/payment-resolver.js --timeout=10000",
+    "test:payment-resolver": "./node_modules/mocha/bin/mocha test/payment-resolver/index.js --timeout=10000",
     "test:user": "./node_modules/mocha/bin/mocha test/user.js --timeout=10000",
+    "test:ai": "./node_modules/mocha/bin/mocha test/ai/index.js --timeout=10000",
     "start": "node src/manager/index.js",
     "prepare": "node -e \"require('prepare-package')()\"",
     "prepare:watch": "nodemon -w ./src -e '*' --exec 'npm run prepare'"

package/src/manager/helpers/middleware.js

@@ -6,6 +6,7 @@
 const path = require('path');
 const powertools = require('node-powertools');
 const { merge } = require('lodash');
+const JSON5 = require('json5');
 
 function Middleware(m, req, res) {
   const self = this;
@@ -27,17 +28,6 @@ Middleware.prototype.run = function (libPath, options) {
   return cors(req, res, async () => {
     const assistant = Manager.Assistant({req: req, res: res});
 
-    // Set properties
-    const data = assistant.request.data;
-    const headers = assistant.request.headers;
-    const method = assistant.request.method;
-    const url = assistant.request.url;
-    const geolocation = assistant.request.geolocation;
-    const client = assistant.request.client;
-
-    // Strip URL
-    const strippedUrl = stripUrl(url);
-
     // Set options
     options = options || {};
     options.authenticate = typeof options.authenticate === 'boolean' ? options.authenticate : true;
@@ -47,11 +37,42 @@ Middleware.prototype.run = function (libPath, options) {
     options.cleanSettings = typeof options.cleanSettings === 'undefined' ? true : options.cleanSettings;
     options.includeNonSchemaSettings = typeof options.includeNonSchemaSettings === 'undefined' ? false : options.includeNonSchemaSettings;
     options.schema = typeof options.schema === 'undefined' ? undefined : options.schema;
+    options.parseMultipartFormData = typeof options.parseMultipartFormData === 'undefined' ? true : options.parseMultipartFormData;
 
     // Set base path
     options.routesDir = typeof options.routesDir === 'undefined' ? `${Manager.cwd}/routes` : options.routesDir;
     options.schemasDir = typeof options.schemasDir === 'undefined' ? `${Manager.cwd}/schemas` : options.schemasDir;
 
+    // Parse multipart/form-data if needed
+    if (options.parseMultipartFormData && req.headers['content-type']?.includes('multipart/form-data')) {
+      try {
+        const parsed = await assistant.parseMultipartFormData();
+        const json = parsed.fields.json || '{}';
+
+        // Parsed JSON
+        if (json) {
+          assistant.request.body = JSON5.parse(json);
+          assistant.request.data = merge({}, assistant.request.body, assistant.request.query);
+        }
+
+        // Log that it was parsed successfully
+        assistant.log(`Middleware.run(): Parsed multipart form data successfully`);
+      } catch (e) {
+        return assistant.respond(new Error(`Failed to parse multipart form data: ${e.message}`), {code: 400, sentry: true});
+      }
+    }
+
+    // Set properties
+    const data = assistant.request.data;
+    const headers = assistant.request.headers;
+    const method = assistant.request.method.toLowerCase();
+    const url = assistant.request.url;
+    const geolocation = assistant.request.geolocation;
+    const client = assistant.request.client;
+
+    // Strip URL
+    const strippedUrl = stripUrl(url);
+
     // Log
     assistant.log(`Middleware.process(): Request (${geolocation.ip} @ ${geolocation.country}, ${geolocation.region}, ${geolocation.city}) [${method} > ${strippedUrl}]`, JSON.stringify(data));
     assistant.log(`Middleware.process(): Headers`, JSON.stringify(headers));
@@ -68,11 +89,24 @@ Middleware.prototype.run = function (libPath, options) {
     }
 
     // Load library
-    // TODO: Support for methods, so first check for method specific file then fallback to index.js
+    // Support for methods, so first check for method specific file then fallback to index.js
     let library;
+
     try {
-      libPath = path.resolve(routesDir, `index.js`);
-      library = new (require(libPath))();
+      // First try to load method-specific file (e.g., get.js, post.js, etc.)
+      const methodFile = `${method}.js`
+      const methodFilePath = path.resolve(routesDir, methodFile);
+
+      try {
+        const finalPath = methodFilePath;
+        library = new (require(finalPath))();
+        assistant.log(`Middleware.process(): Loaded method-specific library: ${methodFile}`);
+      } catch (methodError) {
+        // Fallback to index.js if method-specific file doesn't exist or fails to load
+        const finalPath = path.resolve(routesDir, `index.js`);
+        library = new (require(finalPath))();
+        assistant.log(`Middleware.process(): Method-specific file (${methodFile}) not found, using index.js fallback`);
+      }
     } catch (e) {
       return assistant.respond(new Error(`Unable to load library @ (${libPath}): ${e.message}`), {code: 500, sentry: true});
     }
@@ -113,7 +147,7 @@ Middleware.prototype.run = function (libPath, options) {
         // assistant.schema.name = options.schema;
         assistant.settings = Manager.Settings().resolve(assistant, undefined, data, {dir: schemasDir, schema: options.schema});
       } catch (e) {
-        return assistant.respond(new Error(`Unable to resolve schema ${options.schema}: ${e.message}`), {code: 500, sentry: true});
+        return assistant.respond(new Error(`Unable to resolve schema ${options.schema}: ${e.message}`), {code: e.code || 500, sentry: true});
       }
 
       // Merge settings with data
@@ -128,6 +162,12 @@ Middleware.prototype.run = function (libPath, options) {
 
       // Log
       assistant.log(`Middleware.process(): Resolved settings with schema=${options.schema}`, JSON.stringify(assistant.settings));
+
+      // Log multipart files if they exist
+      const files = assistant.request.multipartData.files || {};
+      if (files) {
+        assistant.log(`Middleware.process(): Multipart files`, JSON.stringify(files));
+      }
     } else {
       assistant.settings = data;
     }

package/src/manager/helpers/settings.js

@@ -42,9 +42,24 @@ Settings.prototype.resolve = function (assistant, schema, settings, options) {
     typeof schema === 'undefined'
     && typeof options.schema !== 'undefined'
   ) {
-    const schemaPath = path.resolve(options.dir, `${options.schema.replace('.js', '')}.js`);
-
-    schema = loadSchema(assistant, schemaPath, settings, options);
+    // Try to load method-specific schema first, then fallback to main schema
+    const method = (assistant?.request?.method || '').toLowerCase();
+    const methodFile = `${method}.js`;
+    const schemaFile = options.schema.replace('.js', '');
+    let schemaPath;
+
+    // First try method-specific schema (e.g., test/get.js, test/post.js)
+    const methodSchemaPath = path.resolve(options.dir, `${schemaFile}/${methodFile}`);
+
+    try {
+      schema = loadSchema(assistant, methodSchemaPath, settings, options);
+      assistant.log(`Settings.resolve(): Loaded method-specific schema: ${schemaFile}/${methodFile}`);
+    } catch (e) {
+      // Fallback to main schema if method-specific doesn't exist
+      schemaPath = path.resolve(options.dir, `${schemaFile}/index.js`);
+      schema = loadSchema(assistant, schemaPath, settings, options);
+      assistant.log(`Settings.resolve(): Method-specific schema not found, using main schema fallback`);
+    }
   }
 
   // If schema is not an object, throw an error

package/src/manager/index.js

@@ -16,7 +16,7 @@ const wrappers = './functions/wrappers';
 
 const BEM_CONFIG_TEMPLATE_PATH = path.resolve(__dirname, '../../templates/backend-manager-config.json');
 
-function Manager(exporter, options) {
+function Manager() {
   const self = this;
 
   // Constants
@@ -64,7 +64,9 @@ Manager.prototype.init = function (exporter, options) {
   options.useFirebaseLogger = typeof options.useFirebaseLogger === 'undefined' ? true : options.useFirebaseLogger;
   options.serviceAccountPath = typeof options.serviceAccountPath === 'undefined' ? 'service-account.json' : options.serviceAccountPath;
   options.backendManagerConfigPath = typeof options.backendManagerConfigPath === 'undefined' ? 'backend-manager-config.json' : options.backendManagerConfigPath;
-  options.fetchStats = typeof options.fetchStats === 'undefined' ? true : options.fetchStats;
+  options.fetchStats = typeof options.fetchStats === 'undefined'
+    ? options.projectType === 'firebase'
+    : options.fetchStats;
   options.checkNodeVersion = typeof options.checkNodeVersion === 'undefined' ? true : options.checkNodeVersion;
   options.uniqueAppName = options.uniqueAppName || undefined;
   options.assistant = options.assistant || {};
@@ -167,10 +169,9 @@ Manager.prototype.init = function (exporter, options) {
 
   // Handle dev environments
   if (self.assistant.isDevelopment()) {
-    const semverMajor = require('semver/functions/major')
-    const semverCoerce = require('semver/functions/coerce')
-    const semverUsing = semverMajor(semverCoerce(process.versions.node));
-    const semverRequired = semverMajor(semverCoerce(self.package?.engines?.node || '0.0.0'));
+    const version = require('wonderful-version');
+    const nodeUsing = version.major(process.versions.node);
+    const nodeRequired = version.major(self.package?.engines?.node || '0.0.0');
 
     // Fix firebase-tools overwriting console.log
     // https://stackoverflow.com/questions/56026747/firebase-console-log-on-localhost
@@ -182,9 +183,9 @@ Manager.prototype.init = function (exporter, options) {
       console.info = logFix;
     }
 
-    // Reject if package.json does not exist
-    if (semverUsing !== semverRequired) {
-      const msg = `Node.js version mismatch: using ${semverUsing} but asked for ${semverRequired}`;
+    // Reject if we're using an unsupported Node.js version
+    if (version.is(nodeUsing, '<', nodeRequired)) {
+      const msg = `Node.js version mismatch: using ${nodeUsing} but asked for ${nodeRequired}`;
       if (options.checkNodeVersion) {
         self.assistant.error(new Error(msg));
         return process.exit(1);