@attlaz/client 1.114.0 → 1.115.0

package/dist/Http/HttpClient.js

@@ -33,7 +33,7 @@ export class HttpClient {
                     clientError.response = {
                         status: rawResponse.status,
                         statusText,
-                        data: JSON.parse(Buffer.from(await rawResponse.arrayBuffer()).toString('utf8')),
+                        data: JSON.parse(await rawResponse.text()),
                     };
                 }
                 catch {
@@ -49,7 +49,9 @@ export class HttpClient {
             // endpoint supplies a parser, a blob read wants the bytes — so sniffing the content type
             // here would be a second, weaker answer to a question already answered. It was also
             // lossy: the old `text()` fallback UTF-8-decoded binary, turning 10 bytes into 16.
-            httpResponse.body = Buffer.from(await rawResponse.arrayBuffer());
+            //
+            // Uint8Array, not Buffer: this runs in the browser too, where Buffer does not exist.
+            httpResponse.body = new Uint8Array(await rawResponse.arrayBuffer());
             return httpResponse;
         }
         catch (error) {

package/dist/Http/HttpClientResponse.d.ts

@@ -2,15 +2,20 @@ import { Headers } from './Data/Headers.js';
 /**
  * A response as it came off the wire. `body` is always bytes — the transport does not interpret,
  * because the caller already knows what it asked for. Use `getJson()` or `getBytes()` to say which.
+ *
+ * Bytes are a `Uint8Array`, never a `Buffer`: this package runs in the browser as well as in Node,
+ * and `Buffer` is a Node global that simply does not exist there — the same reason `Utils` uses
+ * `btoa`/`atob`. A `Buffer` IS a `Uint8Array`, so Node callers can still wrap one without a copy
+ * (`Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)`) when they want its methods.
  */
 export declare class HttpClientResponse {
     status: number;
     statusText: string;
-    body: Buffer | null;
+    body: Uint8Array | null;
     headers: Headers;
     constructor(status: number, statusText: string);
     /** The raw bytes, empty when the response had no body. */
-    getBytes(): Buffer;
+    getBytes(): Uint8Array;
     /**
      * The body parsed as JSON, or null when there was none — a 204 and a DELETE that answers empty
      * are normal, and `JSON.parse('')` throws.

package/dist/Http/HttpClientResponse.js

@@ -1,6 +1,11 @@
 /**
  * A response as it came off the wire. `body` is always bytes — the transport does not interpret,
  * because the caller already knows what it asked for. Use `getJson()` or `getBytes()` to say which.
+ *
+ * Bytes are a `Uint8Array`, never a `Buffer`: this package runs in the browser as well as in Node,
+ * and `Buffer` is a Node global that simply does not exist there — the same reason `Utils` uses
+ * `btoa`/`atob`. A `Buffer` IS a `Uint8Array`, so Node callers can still wrap one without a copy
+ * (`Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)`) when they want its methods.
  */
 export class HttpClientResponse {
     status;
@@ -13,7 +18,7 @@ export class HttpClientResponse {
     }
     /** The raw bytes, empty when the response had no body. */
     getBytes() {
-        return this.body ?? Buffer.alloc(0);
+        return this.body ?? new Uint8Array(0);
     }
     /**
      * The body parsed as JSON, or null when there was none — a 204 and a DELETE that answers empty
@@ -24,6 +29,6 @@ export class HttpClientResponse {
         if (bytes.length === 0) {
             return null;
         }
-        return JSON.parse(bytes.toString('utf8'));
+        return JSON.parse(new TextDecoder().decode(bytes));
     }
 }

package/dist/Http/Transport/DirectTransport.d.ts

@@ -32,7 +32,7 @@ export declare class DirectTransport implements ITransport {
     private parseErrorHandler;
     constructor(defaultBaseUrl: string, sessionPayload: string, sessionSignature: string, routes?: DirectTransportRoute[]);
     request<T>(action: string, parameters?: Parameters, method?: string, _signWithOauthToken?: boolean): Promise<T>;
-    requestBytes(action: string, parameters?: Parameters, method?: string, _signWithOauthToken?: boolean, headers?: Record<string, string>): Promise<Buffer>;
+    requestBytes(action: string, parameters?: Parameters, method?: string, _signWithOauthToken?: boolean, headers?: Record<string, string>): Promise<Uint8Array>;
     private resolveClient;
     isDebugEnabled(): boolean;
     setParseErrorHandler(handler: ParseErrorHandler | null): void;

package/dist/Http/Transport/ITransport.d.ts

@@ -8,7 +8,7 @@ export type ParseErrorHandler = (message: string, context: Record<string, unknow
 export interface ITransport {
     request: <T>(action: string, parameters: Parameters, method: string, signWithOauthToken: boolean) => Promise<T>;
     /** The response bytes, undecoded — for resources a JSON round trip would inflate or destroy. */
-    requestBytes: (action: string, parameters: Parameters, method: string, signWithOauthToken: boolean, headers?: Record<string, string>) => Promise<Buffer>;
+    requestBytes: (action: string, parameters: Parameters, method: string, signWithOauthToken: boolean, headers?: Record<string, string>) => Promise<Uint8Array>;
     isDebugEnabled: () => boolean;
     reportParseError: (message: string, context: Record<string, unknown>) => void;
     setParseErrorHandler: (handler: ParseErrorHandler | null) => void;

package/dist/Http/Transport/OAuthClient.d.ts

@@ -52,7 +52,7 @@ export declare class OAuthClient implements ITransport {
      * Like `request`, but asks for and returns the raw bytes. For a resource that has a binary
      * representation — a stored item — where decoding would destroy it.
      */
-    requestBytes(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean, headers?: Record<string, string>): Promise<Buffer>;
+    requestBytes(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean, headers?: Record<string, string>): Promise<Uint8Array>;
     request<T>(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean): Promise<T>;
     isAuthenticated(): boolean;
     getToken(): OAuthClientToken | null;

package/dist/Http/Transport/OAuthClient.js

@@ -395,9 +395,12 @@ export class OAuthClient {
             requestData.setHeader('Attlaz-API-Version', this.version);
         }
         if ((method === 'POST' || method === 'DELETE' || method === 'PUT' || method === 'PATCH') && parameters !== null && parameters !== undefined) {
-            // A Buffer is the payload, not something to serialise. Stringifying one yields
+            // Raw bytes are the payload, not something to serialise. Stringifying them yields
             // {"type":"Buffer","data":[…]} — larger than the bytes and not what any reader expects.
-            if (Buffer.isBuffer(parameters)) {
+            // Tested with instanceof rather than Buffer.isBuffer: Buffer is a Node global and this
+            // package runs in the browser, where naming it at all is a ReferenceError. A Buffer is
+            // a Uint8Array, so this still catches one.
+            if (parameters instanceof Uint8Array) {
                 requestData.body = parameters;
                 requestData.setHeader('Content-Type', 'application/octet-stream');
             }

package/dist/Service/Endpoint.d.ts

@@ -16,12 +16,12 @@ export declare abstract class Endpoint {
     private formatParameters;
     private formatKey;
     /** Raw response bytes for this action — see `ITransport.requestBytes`. */
-    requestBytes(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean, headers?: Record<string, string>): Promise<Buffer>;
+    requestBytes(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean, headers?: Record<string, string>): Promise<Uint8Array>;
     /**
      * Send raw bytes as the request body. Metadata rides headers because the body IS the value —
      * there is no envelope left to put it in.
      */
-    requestBinary(action: string, value: Buffer, headers?: Record<string, string>): Promise<void>;
+    requestBinary(action: string, value: Uint8Array, headers?: Record<string, string>): Promise<void>;
     requestCollection<T>(action: string | QueryString, parser: (input: any) => T, parameters?: Parameters, method?: string, signWithOauthToken?: boolean): Promise<CollectionResult<T>>;
     requestObject<T>(action: string | QueryString, parameters: Parameters | undefined, parser: (input: Record<string, any>) => T, method?: string, signWithOauthToken?: boolean): Promise<ObjectResult<T>>;
     private toApiError;

package/dist/Service/StorageEndpoint.d.ts

@@ -25,7 +25,7 @@ export declare class StorageEndpoint extends Endpoint {
      * ("do I already have these bytes?") costs headers rather than the whole object.
      */
     hasItem(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItemKey: string): Promise<boolean>;
-    getItemBytes(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItemKey: string): Promise<Buffer>;
+    getItemBytes(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItemKey: string): Promise<Uint8Array>;
     /**
      * Store raw bytes. Metadata travels as headers, since the body is the value.
      *
@@ -33,7 +33,7 @@ export declare class StorageEndpoint extends Endpoint {
      * response `Content-Type`, and without it an image is delivered as `application/octet-stream`,
      * which downloads rather than renders.
      */
-    setItemBytes(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItemKey: string, value: Buffer, expiration?: Date | null, contentType?: string | null): Promise<void>;
+    setItemBytes(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItemKey: string, value: Uint8Array, expiration?: Date | null, contentType?: string | null): Promise<void>;
     setItem(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItem: StorageItem): Promise<StorageItem>;
     deleteItem(projectEnvironmentId: string, storageType: StorageType, bucketKey: string, storageItemKey: string): Promise<boolean>;
 }

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.113.0";
+export declare const VERSION = "1.115.0";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "1.113.0";
+export const VERSION = "1.115.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@attlaz/client",
-  "version": "1.114.0",
+  "version": "1.115.0",
   "description": "Javascript Client to access Attlaz API",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",