@frontera-sdk/core 1.50.37 → 1.50.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontera-sdk/core",
-  "version": "1.50.37",
+  "version": "1.50.38",
   "description": "Frontera app runtime: the platform bridge client, app bootstrap and typed platform client.",
   "keywords": [
     "frontera",

package/src/client.ts

@@ -1,5 +1,10 @@
 import { resolveConfig, type FronteraConfig, type FronteraCredential } from './config'
-import { httpRequest, type RequestOptions } from './transport'
+import {
+  httpRequest,
+  httpRequestEnvelope,
+  httpRequestRaw,
+  type RequestOptions,
+} from './transport'
 
 /**
  * The transport-level entry point. Domain clients (`@frontera-sdk/blueprint`, and
@@ -23,6 +28,24 @@ export class FronteraClient {
     return httpRequest<T>(this.config, path, options, this.fetchImpl)
   }
 
+  /**
+   * Same auth and error mapping as `request`, but the 2xx `Response` comes back
+   * with its body unread — for SSE and other non-JSON payloads. Domain clients
+   * stream through this rather than rebuilding the Authorization header.
+   */
+  requestRaw(path: string, options: RequestOptions = {}): Promise<Response> {
+    return httpRequestRaw(this.config, path, options, this.fetchImpl)
+  }
+
+  /**
+   * Same as `request` but skips the envelope unwrap, so paginated routes keep
+   * `nextCursor` (which sits BESIDE `data` in the envelope and is otherwise
+   * dropped).
+   */
+  requestEnvelope<T>(path: string, options: RequestOptions = {}): Promise<T> {
+    return httpRequestEnvelope<T>(this.config, path, options, this.fetchImpl)
+  }
+
   withCredential(credential: FronteraCredential): FronteraClient {
     return new FronteraClient({ ...this.config, credential }, this.fetchImpl)
   }

package/src/transport.ts

@@ -77,6 +77,80 @@ function buildUrl(config: FronteraConfig, path: string, query?: RequestOptions['
   return url.toString()
 }
 
+/**
+ * Like `httpRequest`, but the 2xx `Response` is returned with its body
+ * untouched. This is what streaming endpoints need: an SSE body can only be
+ * read once, so the transport must not consume it. Non-2xx responses are still
+ * read and mapped to `FronteraError` — an error body is JSON, never a stream.
+ */
+export async function httpRequestRaw(
+  config: FronteraConfig,
+  path: string,
+  options: RequestOptions = {},
+  fetchImpl: typeof fetch = fetch,
+): Promise<Response> {
+  const headers: Record<string, string> = {
+    ...lowerCasedKeys(options.headers),
+    ...authHeaders(config),
+  }
+  // FormData carries its own multipart content type WITH a boundary, which
+  // only it can generate — setting one here, or stringifying it, produces a
+  // body the server cannot parse.
+  const isFormData = typeof FormData !== 'undefined' && options.body instanceof FormData
+  if (options.body !== undefined && !isFormData) headers['content-type'] = 'application/json'
+
+  const response = await fetchImpl(buildUrl(config, path, options.query), {
+    method: options.method ?? 'GET',
+    headers,
+    body:
+      options.body === undefined
+        ? undefined
+        : isFormData
+          ? // `FormData`, not `BodyInit`: the guard above narrowed it to exactly
+            // that, and `BodyInit` is a DOM-lib global the CLI's tsconfig does
+            // not load (`lib: ["ESNext"]`, `types: ["bun"]`) — naming it here
+            // failed that package's typecheck on a file it only borrows.
+            (options.body as FormData)
+          : JSON.stringify(options.body),
+    signal: options.signal,
+  })
+
+  if (!response.ok) {
+    const text = await response.text()
+    let parsed: unknown = null
+    if (text.length > 0) {
+      try {
+        parsed = JSON.parse(text)
+      } catch {
+        parsed = text
+      }
+    }
+    throw errorFromResponse(response.status, parsed)
+  }
+  return response
+}
+
+/**
+ * Like `httpRequest`, but WITHOUT the envelope unwrap. Paginated routes put
+ * `nextCursor` beside `data` in the envelope, so unwrapping to `data` silently
+ * drops the cursor — callers that page need the whole body.
+ */
+export async function httpRequestEnvelope<T>(
+  config: FronteraConfig,
+  path: string,
+  options: RequestOptions = {},
+  fetchImpl: typeof fetch = fetch,
+): Promise<T> {
+  const response = await httpRequestRaw(config, path, options, fetchImpl)
+  const text = await response.text()
+  if (text.length === 0) return null as T
+  try {
+    return JSON.parse(text) as T
+  } catch {
+    return text as T
+  }
+}
+
 /**
  * `fetchImpl` is injectable so tests never touch the network. Production
  * callers omit it and get the platform `fetch`.