@sentry/api 0.427.0 → 0.428.0

package/README.md

@@ -176,6 +176,55 @@ const sentry = createSentryClient(
 const { data, error } = await sentry.listOrganizations();
 ```
 
+### Preparing a raw request
+
+Use `sentry.client.prepareRequest` when a consumer needs to inspect a request
+or send it through its own raw transport. It shares the preparation used by
+ordinary SDK requests: instance and per-call configuration, authentication,
+validation, body serialization, and request interceptors.
+
+```ts
+const sentry = createSentryClient({ baseUrl: "https://example.test/sentry" });
+const request = await sentry.client.prepareRequest({
+  method: "GET",
+  url: "/api/0/organizations/example/events/?field=id&field=title&cursor=old#view",
+  query: { cursor: "opaque-next", per_page: 50 },
+});
+// Both field values remain; the old cursor is replaced and the fragment removed.
+const response = await fetch(request);
+// The consumer owns status handling and reading the raw body.
+```
+
+Preparation does not call the configured `fetch` or parse a response. Auth
+providers, validators and request interceptors still run and can have side
+effects; their errors reject unchanged. The returned native `Request` includes
+the resolved options and request-interceptor changes. Its signal remains linked
+to the caller's unless an interceptor replaces or clears it. Send it directly
+with the chosen transport; calling `client.request` again would repeat preparation.
+Reading `request.clone()` leaves its body available for dispatch. A custom fetch or
+browser adapter can still add credentials, CSRF headers or routing at dispatch.
+
+For endpoints with an existing query, serialized query keys replace all existing
+occurrences of those keys. Explicit `null` input keys also remove existing values,
+even with custom serializers; the serialized output can then add them back.
+Unrelated repeated parameters and their encoding are retained, as is custom
+query-serializer output. The default serializer omits `null` and `undefined`:
+`null` clears the original value, while `undefined` leaves it unchanged.
+Literal URL fragments are removed; encoded `%23` values are retained. These
+rules also apply to ordinary requests through the same URL builder.
+
+Use `bodySerializer: null` for an already serialized string, `FormData`, or
+another native body. For `FormData`, also clear the default JSON content type
+with `headers: { "Content-Type": null }` so `Request` supplies its boundary.
+Otherwise the configured serializer still applies. Native
+`Request` construction can add a content type for strings or form data; prepared
+headers describe that request, not a consumer's earlier input or redacted preview.
+
+Pass decoded server cursors and explicit page sizes as query parameters. The SDK
+does not interpret bookmark formats, select navigation directions or store
+history. Existing custom transports accepted by generated operations do not
+have to implement `prepareRequest`; the factory's concrete transport adds it.
+
 ### Cancellation and custom fetch
 
 Reuse the client and supply an `AbortSignal` for each operation. The caller owns the signal, whether it comes from a command, an MCP tool call, or a query library:

package/dist/client/client.gen.d.ts

@@ -1,2 +1,7 @@
-import type { Client, Config } from './types.gen';
-export declare const createClient: (config?: Config) => Client;
+import type { Client, Config, RequestOptions } from './types.gen';
+/** The concrete SDK transport adds preparation without requiring it from custom Clients. */
+export type PreparedClient = Client & {
+    /** Prepare a native Request using configured auth, serializers and request interceptors, without calling fetch. */
+    prepareRequest(options: RequestOptions & Pick<Required<RequestOptions>, 'method'>): Promise<Request>;
+};
+export declare const createClient: (config?: Config) => PreparedClient;

package/dist/client/index.d.ts

@@ -4,5 +4,6 @@ export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializ
 export { buildClientParams } from '../core/params.gen';
 export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
 export { createClient } from './client.gen';
+export type { PreparedClient } from './client.gen';
 export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen';
 export { createConfig, mergeHeaders } from './utils.gen';

package/dist/client.gen.d.ts

@@ -9,4 +9,4 @@ import type { ClientOptions as ClientOptions2 } from './types.gen';
  * to ensure your client always has the correct values.
  */
 export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
-export declare const client: import("./client").Client;
+export declare const client: import("./client").PreparedClient;

package/dist/index.js

@@ -406,10 +406,21 @@ var getUrl = ({
   if (search.startsWith("?")) {
     search = search.substring(1);
   }
-  if (search) {
-    url += `?${search}`;
-  }
-  return url;
+  url = url.split("#", 1)[0];
+  const queryIndex = url.indexOf("?");
+  const pathname = queryIndex === -1 ? url : url.slice(0, queryIndex);
+  const existing = queryIndex === -1 ? "" : url.slice(queryIndex + 1);
+  const replaced = new Set(new URLSearchParams("?" + search).keys());
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value === null)
+      replaced.add(key);
+  }
+  const retained = existing.split("&").filter((part) => {
+    const key = new URLSearchParams("?" + part).keys().next().value;
+    return part !== "" && (key === undefined || !replaced.has(key));
+  });
+  const combined = [...retained, search].filter(Boolean).join("&");
+  return pathname + (combined ? `?${combined}` : "");
 };
 function getValidRequestBody(options) {
   const hasBody = options.body !== undefined;
@@ -702,7 +713,7 @@ var createClient = (config = {}) => {
     const url = buildUrl(opts);
     return { opts, url };
   };
-  const request = async (options) => {
+  const prepare = async (options) => {
     const { opts, url } = await beforeRequest(options);
     const requestInit = {
       redirect: "follow",
@@ -715,6 +726,11 @@ var createClient = (config = {}) => {
         request2 = await fn(request2, opts);
       }
     }
+    return { request: request2, opts };
+  };
+  const prepareRequest = async (options) => (await prepare(options)).request;
+  const request = async (options) => {
+    const { request: request2, opts } = await prepare(options);
     const _fetch = opts.fetch;
     let response;
     try {
@@ -840,6 +856,7 @@ var createClient = (config = {}) => {
     post: makeMethodFn("POST"),
     put: makeMethodFn("PUT"),
     request,
+    prepareRequest,
     setConfig,
     sse: {
       connect: makeSseFn("CONNECT"),

package/dist/sentry-client.gen.d.ts

@@ -8,7 +8,7 @@ import type * as types from './types.gen';
  * Each method keeps the standalone operation's result and request options.
  */
 export declare function createSentryClient(config?: Config): {
-    readonly client: import("./client").Client;
+    readonly client: import("./client").PreparedClient;
     /**
      * List Your Organizations
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/api",
-  "version": "0.427.0",
+  "version": "0.428.0",
   "description": "Official auto-generated TypeScript client for the Sentry public REST API",
   "keywords": [
     "sentry",