@lenne.tech/nest-server 11.32.2 → 11.32.4

package/src/core/common/helpers/file.helper.ts

@@ -2,6 +2,81 @@ import { MulterOptions } from '@nestjs/platform-express/multer/interfaces/multer
 import { diskStorage } from 'multer';
 import { extname } from 'path';
 
+/**
+ * What an upload endpoint accepts: exact mimetypes and exact file extensions.
+ *
+ * Prefer this over the legacy `RegExp` form. A single expression `.test()`ed
+ * against BOTH the mimetype and the extension searches for a SUBSTRING, so every
+ * alternative matches anywhere inside either value. An allow-list of `text` /
+ * `txt` therefore also accepts `text/html` and `text/xml`, and one containing
+ * `md` accepts every mimetype with "md" in it. Consumers hit this in practice:
+ * a filter documented as "no html" happily accepted a file named `x.txt` that
+ * was sent as `text/html`.
+ *
+ * Two separate sets also remove the reason the expression could not simply be
+ * anchored: it had to carry mimetype FRAGMENTS (`wordprocessingml`, `ms-excel`)
+ * next to bare extensions, and no anchoring satisfies both at once.
+ */
+export interface UploadAllowList {
+  /** Allowed file extensions, lowercase and WITH the leading dot. */
+  extensions: readonly string[];
+  /** Allowed mimetypes, lowercase and without parameters. */
+  mimeTypes: readonly string[];
+}
+
+/**
+ * Default for image uploads — the exact-matching equivalent of the legacy
+ * `/jpeg|jpg|png/`.
+ */
+export const IMAGE_UPLOAD_ALLOW_LIST: UploadAllowList = {
+  extensions: ['.jpeg', '.jpg', '.png'],
+  mimeTypes: ['image/jpeg', 'image/png'],
+};
+
+/**
+ * Types a browser may execute as script when it renders the stored file.
+ *
+ * These are rejected by {@link multerFileFilter} REGARDLESS of the allow-list,
+ * because the danger does not depend on what a given endpoint meant to accept:
+ * an upload served back from the API origin with one of these content types
+ * runs in that origin, with the victim's session. The check is what makes the
+ * legacy `RegExp` path safe for existing consumers without breaking their
+ * expressions — see `allowScriptableTypes` to opt out.
+ */
+export const SCRIPTABLE_UPLOAD_MIME_TYPES: readonly string[] = [
+  'application/javascript',
+  'application/xhtml+xml',
+  'application/xml',
+  'image/svg+xml',
+  'text/html',
+  'text/javascript',
+  'text/xml',
+];
+
+/** Extensions matching {@link SCRIPTABLE_UPLOAD_MIME_TYPES}. */
+export const SCRIPTABLE_UPLOAD_EXTENSIONS: readonly string[] = [
+  '.htm',
+  '.html',
+  '.js',
+  '.mjs',
+  '.svg',
+  '.xhtml',
+  '.xml',
+];
+
+/** Options for {@link multerFileFilter}. */
+export interface MulterFileFilterOptions {
+  /**
+   * Accept markup and script types too (`text/html`, `image/svg+xml`, …).
+   *
+   * Only set this when the stored file is never served from an origin that
+   * carries a session — e.g. a separate download host, or a route that always
+   * answers with `Content-Disposition: attachment` AND
+   * `X-Content-Type-Options: nosniff`.
+   */
+  allowScriptableTypes?: boolean;
+}
+
 /**
  * Helper class for inputs
  * @deprecated use functions directly
@@ -18,14 +93,18 @@ export default class FileHelper {
   /**
    * Get function to filter files for multer with a certain mimetype & extname
    */
-  public static multerFileFilter(fileTypeRegex = /jpeg|jpg|png/) {
-    return multerFileFilter(fileTypeRegex);
+  public static multerFileFilter(
+    accept: RegExp | UploadAllowList = IMAGE_UPLOAD_ALLOW_LIST,
+    options?: MulterFileFilterOptions,
+  ) {
+    return multerFileFilter(accept, options);
   }
 
   /**
    * Get multer options for image upload
    */
   public static multerOptionsForImageUpload(options: {
+    allowList?: UploadAllowList;
     destination?: string;
     fileSize?: number;
     fileTypeRegex?: RegExp;
@@ -35,24 +114,80 @@ export default class FileHelper {
 }
 
 /**
- * Get function to filter files for multer with a certain mimetype & extname
+ * Reduce a reported mimetype to the bare type: lowercase, trimmed, without the
+ * `; charset=…` parameters a user agent may append.
+ */
+function normalizeMimeType(value: string): string {
+  return String(value || '')
+    .split(';')[0]
+    .trim()
+    .toLowerCase();
+}
+
+/**
+ * Get a multer `fileFilter` that accepts only the given mimetypes / extensions.
+ *
+ * Pass an {@link UploadAllowList} — both the mimetype and the extension must
+ * appear in it, each compared as a WHOLE value. The two conditions are
+ * independent: either one alone rejects the file, while a pair that is odd yet
+ * individually allowed (`report.txt` announced as `application/pdf`) passes.
+ * An extension→mimetype MAPPING is deliberately not enforced: user agents
+ * genuinely disagree about office and audio types (macOS reports `.csv` as
+ * `text/plain`), so a mapping rejects legitimate uploads.
+ *
+ * A `RegExp` is still accepted for backwards compatibility but is
+ * **deprecated**: it is `.test()`ed against both values and therefore matches
+ * SUBSTRINGS, which is how `te?xt` ends up accepting `text/html`. Whichever form
+ * is used, the types in {@link SCRIPTABLE_UPLOAD_MIME_TYPES} /
+ * {@link SCRIPTABLE_UPLOAD_EXTENSIONS} are rejected first unless
+ * `options.allowScriptableTypes` is set — that is what closes the hole for
+ * expressions that already exist in consumer projects.
+ *
+ * Rejections are reported as a real `Error`. Passing a bare string (as this
+ * helper did before) leaves multer with an "error" that has no `message`, which
+ * NestJS's `transformException` cannot map to a 4xx.
  */
-export function multerFileFilter(fileTypeRegex = /jpeg|jpg|png/) {
+export function multerFileFilter(
+  accept: RegExp | UploadAllowList = IMAGE_UPLOAD_ALLOW_LIST,
+  options?: MulterFileFilterOptions,
+) {
   return (req, file, cb) => {
-    const mimetype = fileTypeRegex.test(file.mimetype);
-    const extName = fileTypeRegex.test(extname(file.originalname).toLowerCase());
+    const mimeType = normalizeMimeType(file?.mimetype);
+    const extension = extname(String(file?.originalname || '')).toLowerCase();
 
-    if (mimetype && extName) {
+    if (
+      !options?.allowScriptableTypes &&
+      (SCRIPTABLE_UPLOAD_MIME_TYPES.includes(mimeType) || SCRIPTABLE_UPLOAD_EXTENSIONS.includes(extension))
+    ) {
+      return cb(new Error(`File upload rejected: ${mimeType || 'unknown type'} may execute as script`));
+    }
+
+    const accepted =
+      accept instanceof RegExp
+        ? accept.test(mimeType) && accept.test(extension)
+        : accept.mimeTypes.includes(mimeType) && accept.extensions.includes(extension);
+
+    if (accepted) {
       return cb(null, true);
     }
-    cb(`Error: File upload only supports the following filetypes - ${fileTypeRegex}`);
+    cb(new Error(`File upload only supports the following filetypes - ${describeAccept(accept)}`));
   };
 }
 
+/** Render the accepted types for the rejection message. */
+function describeAccept(accept: RegExp | UploadAllowList): string {
+  return accept instanceof RegExp ? String(accept) : accept.extensions.join(', ');
+}
+
 /**
  * Get multer options for image upload
+ *
+ * Pass `allowList` for exact matching; `fileTypeRegex` is deprecated (see
+ * {@link multerFileFilter}). When neither is set, {@link IMAGE_UPLOAD_ALLOW_LIST}
+ * applies.
  */
 export function multerOptionsForImageUpload(options: {
+  allowList?: UploadAllowList;
   destination?: string;
   fileSize?: number;
   fileTypeRegex?: RegExp;
@@ -60,13 +195,16 @@ export function multerOptionsForImageUpload(options: {
   // Set config
   const config = {
     fileSize: 1024 * 1024, // 1MB
-    fileTypeRegex: /jpeg|jpg|png/, // Images only
     ...options,
   };
 
+  // An explicit regex keeps precedence so existing callers behave as before
+  // (minus the scriptable types); otherwise the exact-matching default applies.
+  const accept: RegExp | UploadAllowList = config.fileTypeRegex ?? config.allowList ?? IMAGE_UPLOAD_ALLOW_LIST;
+
   return {
     // File filter
-    fileFilter: config.fileTypeRegex ? multerFileFilter(config.fileTypeRegex) : undefined,
+    fileFilter: multerFileFilter(accept),
 
     // Limits
     limits: {

package/src/core/common/interfaces/server-options.interface.ts

@@ -1110,6 +1110,16 @@ export interface IAiDefaultConnection {
   /** Capability tags (free-form, e.g. 'analysis', 'vision'). */
   capabilities?: string[];
 
+  /**
+   * Total context window (input + output tokens) the model supports. Drives the
+   * orchestrator's context budget (system prompt + history + tool results). Omit to
+   * auto-detect by probing the endpoint / `knownContextWindow()`; set it explicitly
+   * when the endpoint exposes no limit and the model id is unknown to the heuristic
+   * (otherwise the orchestrator assumes the conservative `ai.contextWindow` default
+   * of 8192 and trims the prompt + tool results on every turn).
+   */
+  contextWindow?: number;
+
   /** Default maximum number of tokens for completions. */
   defaultMaxTokens?: number;
 
@@ -1212,6 +1222,19 @@ export interface IAi {
     user?: { maxPrompts?: number; maxTokens?: number };
   };
 
+  /**
+   * Opt-in boot self-check: after startup, probe each enabled connection that declares
+   * an EXPLICIT `supportsNativeTools` / `supportsJsonResponse` and warn (log only) when
+   * the declared value contradicts what the endpoint actually reports — a wrong explicit
+   * flag otherwise silently degrades the assistant (e.g. forcing fragile emulated
+   * tool-calling on a backend that supports native function calling). OFF by default
+   * because it makes outbound calls to the LLM endpoints on every boot; the declared
+   * value is never changed (clear it in the admin UI to re-enable auto-detection). Also
+   * skipped in the ci/e2e runners.
+   * @default false
+   */
+  capabilityDriftCheck?: boolean;
+
   /**
    * Confirmation policy for mutating tool actions (create/update/delete).
    * `destructive` tools always require confirmation regardless of this policy.

package/src/core/modules/ai/README.md

@@ -111,6 +111,12 @@ never probed). Detection runs in two complementary ways:
   once, persists, and uses the result. Until then the safe emulated baseline applies.
 - **On demand:** admins can re-probe via `detectAiConnectionCapabilities` /
   `POST /ai/connections/:id/detect-capabilities` (e.g. after changing `baseUrl`/`model`).
+- **Boot drift check (opt-in):** set `ai.capabilityDriftCheck: true` to probe every enabled
+  connection that has an EXPLICIT flag once at startup and log a warning when the declared
+  value contradicts what the endpoint reports (a wrong explicit flag otherwise degrades the
+  assistant silently, e.g. forcing emulated tool-calling on a native-capable backend). It only
+  warns — the stored value is never changed. OFF by default because it makes outbound calls to
+  the LLM endpoints on every boot; also skipped in the ci/e2e runners.
 
 The probe is provider-agnostic best effort: `response_format: json_object` is sent
 (2xx → JSON supported); a trivial tool with `tool_choice: 'required'` is sent (2xx

package/src/core/modules/ai/inputs/core-ai-connection.input.ts

@@ -1,4 +1,5 @@
 import { InputType } from '@nestjs/graphql';
+import { IsInt, Min } from 'class-validator';
 
 import { Restricted } from '../../../common/decorators/restricted.decorator';
 import { UnifiedField } from '../../../common/decorators/unified-field.decorator';
@@ -72,6 +73,7 @@ export class CoreAiConnectionInput {
     isOptional: true,
     roles: RoleEnum.ADMIN,
     type: () => Number,
+    validator: (options) => [IsInt(options), Min(1, options)],
   })
   contextWindow?: number = undefined;
 

package/src/core/modules/ai/interfaces/ai-tool.interface.ts

@@ -69,9 +69,21 @@ export interface IAiTool {
 
   /**
    * Whether the tool performs a destructive/irreversible action (delete, bulk
-   * update, payment, …). Destructive tools always require confirmation: they are
-   * NOT executed until the prompt is re-sent with `confirm: true`; the first
-   * response lists them as `pendingActions` with `requiresConfirmation: true`.
+   * update, payment, …). In the CHAT orchestrator destructive tools always require
+   * confirmation: they are NOT executed until the prompt is re-sent with
+   * `confirm: true`; the first response lists them as `pendingActions` with
+   * `requiresConfirmation: true`.
+   *
+   * **No confirmation gate over MCP.** `CoreAiMcpService.mcpCallTool` consults
+   * neither this flag nor {@link IAiTool.mutating}, so a destructive tool invoked
+   * through `/ai/mcp` executes IMMEDIATELY, on the first call. This flag is
+   * therefore a chat-orchestrator contract, not a global execution barrier. The
+   * barriers that DO hold on every path are the registry role filter ({@link
+   * IAiTool.roles}, applied by `forUser()` before `execute()`) and the authorization
+   * inside `execute()` itself — so a destructive tool restricted to a real role stays
+   * unreachable by lesser-privileged MCP clients; MCP only skips the extra confirmation
+   * step for clients that may already see the tool. Expose MCP only to clients you trust
+   * to obtain user consent themselves.
    */
   readonly destructive?: boolean;
 
@@ -80,6 +92,9 @@ export interface IAiTool {
    * mutating tools is governed by the `ai.confirmation` policy (admin default,
    * optionally client-overridable, optionally enforced). `destructive` is the
    * stronger flag and always requires confirmation regardless of policy.
+   *
+   * Same MCP caveat as {@link IAiTool.destructive}: the confirmation policy is not
+   * evaluated on the `/ai/mcp` path at all.
    */
   readonly mutating?: boolean;
 

package/src/core/modules/ai/services/core-ai-connection.service.ts

@@ -32,6 +32,29 @@ import { AI_CONNECTION_CLASS, AI_CONNECTION_MODEL } from '../core-ai.constants';
  */
 export { AI_CONNECTION_CLASS, AI_CONNECTION_MODEL } from '../core-ai.constants';
 
+/**
+ * Minimal shape of a persisted (lean) connection document that the boot-time drift
+ * check needs to build a provider for a probe. It mirrors the fields
+ * {@link CoreAiConnectionService.resolve} reads, declared locally so the drift check can
+ * use the bulk `find()` result directly (no per-connection re-read / N+1).
+ */
+type ResolvableConnectionDoc = {
+  _id: unknown;
+  apiKeyEncrypted?: string;
+  apiKeyEnv?: string;
+  baseUrl: string;
+  contextWindow?: number;
+  defaultMaxTokens?: number;
+  defaultTemperature?: number;
+  defaultUserMaxPeriod?: string;
+  defaultUserMaxTokens?: number;
+  model: string;
+  name: string;
+  providerType?: string;
+  supportsJsonResponse?: boolean;
+  supportsNativeTools?: boolean;
+};
+
 /**
  * CRUD service for {@link CoreAiConnection} — the database-backed LLM
  * configuration. Admin-only (enforced by the model's `@Restricted(ADMIN)` plus
@@ -75,6 +98,9 @@ export class CoreAiConnectionService
   async onModuleInit(): Promise<void> {
     await this.seedDefaultConnection();
     await this.assertStoredKeysDecryptable();
+    // Best-effort, non-blocking: probe endpoints and warn on capability drift. Never
+    // awaited so a slow/unreachable endpoint cannot delay boot.
+    void this.warnOnCapabilityDrift();
   }
 
   /**
@@ -142,6 +168,115 @@ export class CoreAiConnectionService
     }
   }
 
+  /**
+   * Opt-in boot self-check (`ai.capabilityDriftCheck`, default OFF): warn when a
+   * connection DECLARES a capability that contradicts what its endpoint actually
+   * reports. Capabilities are auto-detected only for flags left UNDEFINED (create +
+   * lazy runtime path); an EXPLICIT `supportsNativeTools` / `supportsJsonResponse` is
+   * authoritative and is never re-probed by the normal path — so a wrong explicit flag
+   * silently degrades the assistant forever (e.g. `supportsNativeTools: false` on an
+   * endpoint that DOES support native function calling forces fragile emulated
+   * tool-calling, which weaker models do not sustain once the prompt grows).
+   *
+   * To observe the endpoint's REAL capability for a DECLARED flag, it builds the provider
+   * with the flags cleared to `undefined` — otherwise the provider's `detectCapabilities()`,
+   * which probes ONLY undefined flags, would return nothing to compare against (the whole
+   * point of the check) — then diffs the probed booleans against the stored declaration.
+   *
+   * It NEVER changes the stored value (the admin's explicit choice stays authoritative),
+   * NEVER blocks boot (fire-and-forget, all errors swallowed), and issues outbound calls
+   * to the LLM endpoints — hence it is OFF by default and additionally skipped in the
+   * ci/e2e runners. It reads every enabled connection in a single query (no per-connection
+   * re-read). Connections that leave BOTH flags undefined are handled by
+   * {@link detectAndPersistCapabilities} and are skipped here (nothing declared to check).
+   */
+  protected async warnOnCapabilityDrift(): Promise<void> {
+    // Opt-in: a framework boot must not contact third-party endpoints unless asked.
+    if (!ConfigService.get<boolean>('ai.capabilityDriftCheck')) {
+      return;
+    }
+    // Defense in depth: never probe from the integration test runner (real module boot).
+    // The unit runner (NODE_ENV=test) is intentionally NOT excluded so the method stays
+    // unit-testable with a mocked providerFactory — the opt-in flag above already prevents
+    // accidental probing there.
+    if (!this.providerFactory || ['ci', 'e2e'].includes(process.env.NODE_ENV ?? '')) {
+      return;
+    }
+    try {
+      // Single read (no per-connection re-resolve): the full docs carry everything the
+      // provider factory needs, so there is no N+1 findById per connection.
+      const docs = (await this.mainDbModel
+        .find({ enabled: { $ne: false } })
+        .lean()
+        .exec()) as unknown as ResolvableConnectionDoc[];
+      for (const doc of docs) {
+        // Only a connection that DECLARES a capability can drift; undefined flags are
+        // auto-detected on first use, so there is nothing to reconcile here.
+        if (typeof doc.supportsNativeTools !== 'boolean' && typeof doc.supportsJsonResponse !== 'boolean') {
+          continue;
+        }
+        let provider: { detectCapabilities?: () => Promise<{ jsonResponse?: boolean; nativeTools?: boolean }> };
+        try {
+          // Clear the declared flags so detectCapabilities() actually probes them (it
+          // skips any flag that is already a boolean on the connection).
+          const probeConnection: ResolvedAiConnection = {
+            apiKey: this.resolveApiKeyFromDoc(doc) ?? '',
+            baseUrl: doc.baseUrl,
+            contextWindow: doc.contextWindow,
+            defaultMaxTokens: doc.defaultMaxTokens,
+            defaultTemperature: doc.defaultTemperature,
+            defaultUserMaxPeriod: doc.defaultUserMaxPeriod,
+            defaultUserMaxTokens: doc.defaultUserMaxTokens,
+            id: String(doc._id),
+            model: doc.model,
+            name: doc.name,
+            providerType: doc.providerType || 'openai-compatible',
+            supportsJsonResponse: undefined,
+            supportsNativeTools: undefined,
+          };
+          provider = this.providerFactory.create(probeConnection);
+        } catch {
+          continue; // unresolvable / unbuildable — nothing to compare against
+        }
+        if (typeof provider.detectCapabilities !== 'function') {
+          continue;
+        }
+        const detected = await provider.detectCapabilities().catch(() => undefined);
+        if (!detected) {
+          continue; // probe failed (endpoint down / transport error) — not a drift signal
+        }
+        const drift: string[] = [];
+        if (
+          typeof doc.supportsNativeTools === 'boolean' &&
+          typeof detected.nativeTools === 'boolean' &&
+          doc.supportsNativeTools !== detected.nativeTools
+        ) {
+          drift.push(
+            `supportsNativeTools declared ${doc.supportsNativeTools} but the endpoint reports ${detected.nativeTools}`,
+          );
+        }
+        if (
+          typeof doc.supportsJsonResponse === 'boolean' &&
+          typeof detected.jsonResponse === 'boolean' &&
+          doc.supportsJsonResponse !== detected.jsonResponse
+        ) {
+          drift.push(
+            `supportsJsonResponse declared ${doc.supportsJsonResponse} but the endpoint reports ${detected.jsonResponse}`,
+          );
+        }
+        if (drift.length) {
+          this.logger.warn(
+            `AI connection "${doc.name || String(doc._id)}" capability drift: ${drift.join('; ')}. ` +
+              `The declared value is authoritative and was NOT changed — correct it in the admin UI, or clear it to ` +
+              `re-enable auto-detection, so the assistant uses the endpoint's real capabilities.`,
+          );
+        }
+      }
+    } catch (err) {
+      this.logger.warn(`AI capability drift check skipped: ${(err as Error).message}`);
+    }
+  }
+
   /**
    * Create a connection. Encrypts the optional plaintext `apiKey` and keeps the
    * default connection unique.

package/src/core/modules/file/README.md

@@ -74,6 +74,65 @@ export class FileController extends CoreFileController {
 }
 ```
 
+Access can also be restricted per file by overriding `CoreFileService.checkRights()`. When it
+refuses, `getFileStream()` returns `null` and the controller answers **404** — deliberately the same
+answer as an unknown id, so the endpoint cannot be used to probe which files exist. Do not change
+this to a 403 in an override without accepting that trade-off.
+
+### Error responses
+
+| Situation                                                                              | Status | Body                                                                                                  |
+| -------------------------------------------------------------------------------------- | ------ | ----------------------------------------------------------------------------------------------------- |
+| Unknown id / filename, or `checkRights()` refused                                      | `404`  | `NotFoundException` with `ErrorCode.FILE_NOT_FOUND`                                                   |
+| Missing id / filename in the route                                                     | `400`  | `BadRequestException` with `ErrorCode.REQUIRED_FIELD_MISSING`                                         |
+| GridFS read fails **before** any byte was sent (file document exists, chunks are gone) | `404`  | `{ "error": "Not Found", "message": "<FILE_NOT_FOUND>", "statusCode": 404 }`                          |
+| GridFS read fails **after** streaming started                                          | —      | The connection is closed; a truncated transfer is the only signal left once the status is on the wire |
+
+The mid-stream failure case is handled by `pipeFileToResponse()`. Without it the stream error would
+go unhandled, Node would destroy the socket, and a reverse proxy would report **502 Bad Gateway** —
+i.e. "the server is down", while every other route keeps answering. On the error path the headers
+describing the file (`Content-Type`, `Content-Disposition`, `Cache-Control`, `ETag`) are removed, so
+the JSON body is not labelled as the image it failed to deliver. The error itself is logged
+server-side even though the client answer stays deliberately generic.
+
+To change the status, the body or the logging, override the `protected pipeFileToResponse()` method
+on the controller rather than the exported function of the same name.
+
+### Upload filtering
+
+Upload endpoints are project-specific, but the filter they install comes from the framework
+(`multerOptionsForImageUpload()` / `multerFileFilter()` in `common/helpers/file.helper.ts`). Name what
+the endpoint accepts as an `UploadAllowList` — both the mimetype and the extension are compared as
+WHOLE values:
+
+```typescript
+@UseInterceptors(FileInterceptor('file', multerOptionsForImageUpload({
+  allowList: {
+    extensions: ['.jpeg', '.jpg', '.pdf', '.png'],
+    mimeTypes: ['application/pdf', 'image/jpeg', 'image/png'],
+  },
+})))
+```
+
+The two conditions are **independent**: either one alone rejects the file, while a pair that is odd
+yet individually allowed (`report.txt` announced as `application/pdf`) passes. An extension→mimetype
+MAPPING is deliberately not enforced, because user agents genuinely disagree about office and audio
+types (macOS reports `.csv` as `text/plain`) and a mapping would reject legitimate uploads.
+
+The legacy `fileTypeRegex` option still works and keeps precedence, but is **deprecated**: one
+expression is `.test()`ed against both the mimetype and the extension, so every alternative matches
+as a SUBSTRING — an allow-list containing `te?xt` also accepts `text/html`.
+
+Types a browser may execute as script (`text/html`, `image/svg+xml`, `application/xhtml+xml`, XML and
+JavaScript types, plus the matching extensions) are rejected **before** the allow-list is consulted,
+on both forms. A stored upload served back from the API origin with one of these content types runs
+in that origin, with the victim's session. Opt out only when the file never reaches an origin that
+carries a session:
+
+```typescript
+multerFileFilter({ extensions: ['.svg'], mimeTypes: ['image/svg+xml'] }, { allowScriptableTypes: true });
+```
+
 ---
 
 ## GraphQL Support