@attlaz/client 1.114.0 → 1.115.2

package/dist/Http/ClientError.d.ts

@@ -2,6 +2,14 @@ export declare class ClientError extends Error {
     httpStatus: number | null;
     message: string;
     response: unknown;
+    /**
+     * The error this one was built from, when it wraps another (see {@link fromError}).
+     *
+     * Declared here rather than relying on the built-in `Error.cause`: that is ES2022 and this
+     * package compiles against es2017 so it still runs in older browsers. Assigning the property
+     * works on any engine, and a modern one treats it as the standard field.
+     */
+    cause?: unknown;
     constructor(message: string, httpErrorCode?: number | null);
     /**
      * Type guard: true when `error` is a ClientError (or a subclass such as ApiError). Use it to

package/dist/Http/ClientError.js

@@ -3,6 +3,14 @@ export class ClientError extends Error {
     httpStatus = null;
     message;
     response;
+    /**
+     * The error this one was built from, when it wraps another (see {@link fromError}).
+     *
+     * Declared here rather than relying on the built-in `Error.cause`: that is ES2022 and this
+     * package compiles against es2017 so it still runs in older browsers. Assigning the property
+     * works on any engine, and a modern one treats it as the standard field.
+     */
+    cause;
     constructor(message, httpErrorCode = null) {
         super(message);
         this.message = message;
@@ -36,13 +44,22 @@ export class ClientError extends Error {
             return error;
         }
         // The transport uses fetch, which throws TypeError on network failures (DNS, refused
-        // connection, TLS, etc.). Anything else reaching here is unexpected — surface it as a
-        // generic 500 while keeping the original name/stack for debugging.
+        // connection, TLS, etc.). That case keeps its own wording: "Service not available" says
+        // more to a caller than fetch's own "Failed to fetch".
+        //
+        // Anything else is unexpected, and its message is the only description of what actually
+        // went wrong — so it is carried through rather than replaced. This used to read
+        // 'Unknown error', which cost a production outage: a ReferenceError from a Node-only
+        // global in the browser reached the user as "Unknown error" with nothing naming Buffer,
+        // and the console showed the same for every failed call.
         const clientError = error instanceof TypeError
             ? new ClientError('Service not available', HttpStatus.HTTP_UNAVAILABLE)
-            : new ClientError('Unknown error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
+            : new ClientError(error.message === '' ? 'Unknown error' : error.message, HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
         clientError.name = error.name;
         clientError.stack = error.stack;
+        // The original survives as `cause`, so a handler can inspect the real error even where the
+        // message has been rewritten — the TypeError branch above being exactly that case.
+        clientError.cause = error;
         return clientError;
     }
     static byStatus(statusCode, statusText) {

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/Endpoint.js

@@ -168,10 +168,17 @@ export class Endpoint {
             }
             return apiError;
         }
-        if (this.httpClient.isDebugEnabled()) {
-            console.error('Unrecognised error type (not a ClientError)', { error });
-        }
-        return new ApiError('Unknown Error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
+        // Not a ClientError at all — a bug in this client or in a dependency, rather than anything
+        // the API said. Its message is carried through and the original attached as `cause`:
+        // replacing both with 'Unknown Error' is what made a browser-only ReferenceError
+        // undiagnosable from the console during a production outage.
+        const apiError = new ApiError(error instanceof Error && error.message !== '' ? error.message : 'Unknown Error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
+        if (error instanceof Error) {
+            apiError.name = error.name;
+            apiError.stack = error.stack;
+        }
+        apiError.cause = error;
+        return apiError;
     }
     parseCollection(rawData, parser) {
         const data = [];

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.2";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@attlaz/client",
-  "version": "1.114.0",
+  "version": "1.115.2",
   "description": "Javascript Client to access Attlaz API",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -20,7 +20,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://bitbucket.org/attlaz/javascript-client.git"
+    "url": "git+https://github.com/Attlaz-Platform/JS-Client.git"
   },
   "homepage": "https://attlaz.com",
   "keywords": [
@@ -49,7 +49,6 @@
   },
   "publishConfig": {
     "access": "public",
-    "cache": "~/.npm",
     "registry": "https://registry.npmjs.org"
   },
   "devDependencies": {