@moovio/sdk 0.0.0-dev.3 → 0.0.0-dev.31

package/lib/encodings.js

@@ -13,8 +13,9 @@ exports.encodeJSON = encodeJSON;
 exports.queryJoin = queryJoin;
 exports.queryEncoder = queryEncoder;
 exports.appendForm = appendForm;
+exports.normalizeBlob = normalizeBlob;
 const base64_js_1 = require("./base64.js");
-const is_plain_object_js_1 = require("./is-plain-object.js");
+const primitives_js_1 = require("./primitives.js");
 class EncodingError extends Error {
     constructor(message) {
         super(message);
@@ -22,6 +23,20 @@ class EncodingError extends Error {
     }
 }
 exports.EncodingError = EncodingError;
+const reservedEscapes = /%(2[346bcf]|3[abdf]|40|5[bd])/gi;
+function encodeKeyChars(v, charEncoding) {
+    return encodeChars(v, charEncoding === "percentExceptReserved" ? "percent" : charEncoding);
+}
+function encodeChars(v, charEncoding) {
+    switch (charEncoding) {
+        case "percent":
+            return encodeURIComponent(v);
+        case "percentExceptReserved":
+            return encodeURIComponent(v).replace(reservedEscapes, (m) => decodeURIComponent(m));
+        default:
+            return v;
+    }
+}
 function encodeMatrix(key, value, options) {
     let out = "";
     const pairs = options?.explode
@@ -31,7 +46,7 @@ function encodeMatrix(key, value, options) {
         return;
     }
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encodeValue = (v) => encodeString(serializeValue(v));
     pairs.forEach(([pk, pv]) => {
@@ -43,7 +58,7 @@ function encodeMatrix(key, value, options) {
         else if (Array.isArray(pv)) {
             encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(",");
         }
-        else if ((0, is_plain_object_js_1.isPlainObject)(pv)) {
+        else if ((0, primitives_js_1.isPlainObject)(pv)) {
             const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
                 return `,${encodeString(k)},${encodeValue(v)}`;
             });
@@ -55,7 +70,7 @@ function encodeMatrix(key, value, options) {
         if (encValue == null) {
             return;
         }
-        const keyPrefix = encodeString(pk);
+        const keyPrefix = encodeKeyChars(pk, options?.charEncoding);
         tmp = `${keyPrefix}=${encValue}`;
         // trim trailing '=' if value was empty
         if (tmp === `${keyPrefix}=`) {
@@ -78,7 +93,7 @@ function encodeLabel(key, value, options) {
         return;
     }
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encodeValue = (v) => encodeString(serializeValue(v));
     pairs.forEach(([pk, pv]) => {
@@ -89,15 +104,15 @@ function encodeLabel(key, value, options) {
         else if (Array.isArray(pv)) {
             encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(".");
         }
-        else if ((0, is_plain_object_js_1.isPlainObject)(pv)) {
+        else if ((0, primitives_js_1.isPlainObject)(pv)) {
             const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
                 return `.${encodeString(k)}.${encodeValue(v)}`;
             });
             encValue = mapped?.join("").slice(1);
         }
         else {
-            const k = options?.explode && (0, is_plain_object_js_1.isPlainObject)(value)
-                ? `${encodeString(pk)}=`
+            const k = options?.explode && (0, primitives_js_1.isPlainObject)(value)
+                ? `${encodeKeyChars(pk, options?.charEncoding)}=`
                 : "";
             encValue = `${k}${encodeValue(pv)}`;
         }
@@ -115,7 +130,7 @@ function formEncoder(sep) {
             return;
         }
         const encodeString = (v) => {
-            return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+            return encodeChars(v, options?.charEncoding);
         };
         const encodeValue = (v) => encodeString(serializeValue(v));
         const encodedSep = encodeString(sep);
@@ -128,7 +143,7 @@ function formEncoder(sep) {
             else if (Array.isArray(pv)) {
                 encValue = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(encodedSep);
             }
-            else if ((0, is_plain_object_js_1.isPlainObject)(pv)) {
+            else if ((0, primitives_js_1.isPlainObject)(pv)) {
                 encValue = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
                     return `${encodeString(k)}${encodedSep}${encodeValue(v)}`;
                 })?.join(encodedSep);
@@ -139,7 +154,7 @@ function formEncoder(sep) {
             if (encValue == null) {
                 return;
             }
-            tmp = `${encodeString(pk)}=${encValue}`;
+            tmp = `${encodeKeyChars(pk, options?.charEncoding)}=${encValue}`;
             // If we end up with the nothing then skip forward
             if (!tmp || tmp === "=") {
                 return;
@@ -158,7 +173,7 @@ function encodeBodyForm(key, value, options) {
         ? explode(key, value)
         : [[key, value]];
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encodeValue = (v) => encodeString(serializeValue(v));
     pairs.forEach(([pk, pv]) => {
@@ -170,13 +185,13 @@ function encodeBodyForm(key, value, options) {
         else if (Array.isArray(pv)) {
             encValue = JSON.stringify(pv, jsonReplacer);
         }
-        else if ((0, is_plain_object_js_1.isPlainObject)(pv)) {
+        else if ((0, primitives_js_1.isPlainObject)(pv)) {
             encValue = JSON.stringify(pv, jsonReplacer);
         }
         else {
             encValue = `${encodeValue(pv)}`;
         }
-        tmp = `${encodeString(pk)}=${encValue}`;
+        tmp = `${encodeKeyChars(pk, options?.charEncoding)}=${encValue}`;
         // If we end up with the nothing then skip forward
         if (!tmp || tmp === "=") {
             return;
@@ -189,7 +204,7 @@ function encodeDeepObject(key, value, options) {
     if (value == null) {
         return;
     }
-    if (!(0, is_plain_object_js_1.isPlainObject)(value)) {
+    if (!(0, primitives_js_1.isPlainObject)(value)) {
         throw new EncodingError(`Value of parameter '${key}' which uses deepObject encoding must be an object or null`);
     }
     return encodeDeepObjectObject(key, value, options);
@@ -200,9 +215,9 @@ function encodeDeepObjectObject(key, value, options) {
     }
     let out = "";
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
-    if (!(0, is_plain_object_js_1.isPlainObject)(value)) {
+    if (!(0, primitives_js_1.isPlainObject)(value)) {
         throw new EncodingError(`Expected parameter '${key}' to be an object.`);
     }
     Object.entries(value).forEach(([ck, cv]) => {
@@ -210,14 +225,14 @@ function encodeDeepObjectObject(key, value, options) {
             return;
         }
         const pk = `${key}[${ck}]`;
-        if ((0, is_plain_object_js_1.isPlainObject)(cv)) {
+        if ((0, primitives_js_1.isPlainObject)(cv)) {
             const objOut = encodeDeepObjectObject(pk, cv, options);
             out += objOut == null ? "" : `&${objOut}`;
             return;
         }
         const pairs = Array.isArray(cv) ? cv : [cv];
         const encoded = mapDefined(pairs, (v) => {
-            return `${encodeString(pk)}=${encodeString(serializeValue(v))}`;
+            return `${encodeKeyChars(pk, options?.charEncoding)}=${encodeString(serializeValue(v))}`;
         })?.join("&");
         out += encoded == null ? "" : `&${encoded}`;
     });
@@ -228,10 +243,12 @@ function encodeJSON(key, value, options) {
         return;
     }
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encVal = encodeString(JSON.stringify(value, jsonReplacer));
-    return options?.explode ? encVal : `${encodeString(key)}=${encVal}`;
+    return options?.explode
+        ? encVal
+        : `${encodeKeyChars(key, options?.charEncoding)}=${encVal}`;
 }
 const encodeSimple = (key, value, options) => {
     let out = "";
@@ -242,7 +259,7 @@ const encodeSimple = (key, value, options) => {
         return;
     }
     const encodeString = (v) => {
-        return options?.charEncoding === "percent" ? encodeURIComponent(v) : v;
+        return encodeChars(v, options?.charEncoding);
     };
     const encodeValue = (v) => encodeString(serializeValue(v));
     pairs.forEach(([pk, pv]) => {
@@ -253,14 +270,14 @@ const encodeSimple = (key, value, options) => {
         else if (Array.isArray(pv)) {
             tmp = mapDefined(pv, (v) => `${encodeValue(v)}`)?.join(",");
         }
-        else if ((0, is_plain_object_js_1.isPlainObject)(pv)) {
+        else if ((0, primitives_js_1.isPlainObject)(pv)) {
             const mapped = mapDefinedEntries(Object.entries(pv), ([k, v]) => {
                 return `,${encodeString(k)},${encodeValue(v)}`;
             });
             tmp = mapped?.join("").slice(1);
         }
         else {
-            const k = options?.explode && (0, is_plain_object_js_1.isPlainObject)(value) ? `${pk}=` : "";
+            const k = options?.explode && (0, primitives_js_1.isPlainObject)(value) ? `${pk}=` : "";
             tmp = `${k}${encodeValue(pv)}`;
         }
         out += tmp ? `,${tmp}` : "";
@@ -272,7 +289,7 @@ function explode(key, value) {
     if (Array.isArray(value)) {
         return value.map((v) => [key, v]);
     }
-    else if ((0, is_plain_object_js_1.isPlainObject)(value)) {
+    else if ((0, primitives_js_1.isPlainObject)(value)) {
         const o = value ?? {};
         return Object.entries(o).map(([k, v]) => [k, v]);
     }
@@ -362,18 +379,39 @@ exports.encodeFormQuery = queryEncoder(exports.encodeForm);
 exports.encodeSpaceDelimitedQuery = queryEncoder(exports.encodeSpaceDelimited);
 exports.encodePipeDelimitedQuery = queryEncoder(exports.encodePipeDelimited);
 exports.encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
+function isBlobLike(val) {
+    if (val instanceof Blob) {
+        return true;
+    }
+    if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+        return false;
+    }
+    const tag = val[Symbol.toStringTag];
+    if (tag !== "Blob" && tag !== "File") {
+        return false;
+    }
+    return "stream" in val && typeof val.stream === "function";
+}
 function appendForm(fd, key, value, fileName) {
     if (value == null) {
         return;
     }
-    else if (value instanceof Blob && fileName) {
-        fd.append(key, value, fileName);
-    }
-    else if (value instanceof Blob) {
-        fd.append(key, value);
+    else if (isBlobLike(value)) {
+        if (fileName) {
+            fd.append(key, value, fileName);
+        }
+        else {
+            fd.append(key, value);
+        }
     }
     else {
         fd.append(key, String(value));
     }
 }
+async function normalizeBlob(value) {
+    if (value instanceof Blob) {
+        return value;
+    }
+    return new Blob([await value.arrayBuffer()], { type: value.type });
+}
 //# sourceMappingURL=encodings.js.map

package/lib/files.d.ts

@@ -10,4 +10,17 @@ export declare function readableStreamToArrayBuffer(readable: ReadableStream<Uin
  * Returns null if the extension is not recognized.
  */
 export declare function getContentTypeFromFileName(fileName: string): string | null;
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+export declare function bytesToBlob(content: Uint8Array<ArrayBufferLike> | ArrayBuffer | Blob | string, contentType: string): Blob;
 //# sourceMappingURL=files.d.ts.map

package/lib/files.js

@@ -5,6 +5,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readableStreamToArrayBuffer = readableStreamToArrayBuffer;
 exports.getContentTypeFromFileName = getContentTypeFromFileName;
+exports.bytesToBlob = bytesToBlob;
 /**
  * Consumes a stream and returns a concatenated array buffer. Useful in
  * situations where we need to read the whole file because it forms part of a
@@ -74,4 +75,22 @@ function getContentTypeFromFileName(fileName) {
     };
     return mimeTypes[ext] || null;
 }
+/**
+ * Creates a Blob from file content with the given MIME type.
+ *
+ * Node.js Buffers are Uint8Array subclasses that may share a pooled
+ * ArrayBuffer (byteOffset > 0, byteLength < buffer.byteLength). Passing
+ * such a Buffer directly to `new Blob([buf])` can include the entire
+ * underlying pool on some runtimes, producing a Blob with extra bytes
+ * that corrupts multipart uploads.
+ *
+ * Copying into a standalone Uint8Array ensures the Blob receives only the
+ * intended bytes regardless of runtime behaviour.
+ */
+function bytesToBlob(content, contentType) {
+    if (content instanceof Uint8Array) {
+        return new Blob([new Uint8Array(content)], { type: contentType });
+    }
+    return new Blob([content], { type: contentType });
+}
 //# sourceMappingURL=files.js.map

package/lib/http.d.ts

@@ -17,11 +17,11 @@ export type BeforeRequestHook = (req: Request) => Awaitable<Request | void>;
 export type RequestErrorHook = (err: unknown, req: Request) => Awaitable<void>;
 export type ResponseHook = (res: Response, req: Request) => Awaitable<void>;
 export declare class HTTPClient {
-    private options;
     private fetcher;
     private requestHooks;
     private requestErrorHooks;
     private responseHooks;
+    private options;
     constructor(options?: HTTPClientOptions);
     request(request: Request): Promise<Response>;
     /**

package/lib/http.js

@@ -24,10 +24,10 @@ const DEFAULT_FETCHER = (input, init) => {
 };
 class HTTPClient {
     constructor(options = {}) {
-        this.options = options;
         this.requestHooks = [];
         this.requestErrorHooks = [];
         this.responseHooks = [];
+        this.options = options;
         this.fetcher = options.fetcher || DEFAULT_FETCHER;
     }
     async request(request) {

package/lib/matchers.js

@@ -24,7 +24,7 @@ const apierror_js_1 = require("../models/errors/apierror.js");
 const responsevalidationerror_js_1 = require("../models/errors/responsevalidationerror.js");
 const fp_js_1 = require("../types/fp.js");
 const http_js_1 = require("./http.js");
-const is_plain_object_js_1 = require("./is-plain-object.js");
+const primitives_js_1 = require("./primitives.js");
 const DEFAULT_CONTENT_TYPES = {
     jsonl: "application/jsonl",
     json: "application/json",
@@ -140,7 +140,6 @@ function match(...matchers) {
                 raw = body;
                 break;
             default:
-                encoding;
                 throw new Error(`Unsupported response type: ${encoding}`);
         }
         if (matcher.enc === "fail") {
@@ -155,7 +154,7 @@ function match(...matchers) {
             data = {
                 ...options?.extraFields,
                 ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-                ...((0, is_plain_object_js_1.isPlainObject)(raw) ? raw : null),
+                ...((0, primitives_js_1.isPlainObject)(raw) ? raw : null),
                 request$: request,
                 response$: response,
                 body$: body,
@@ -172,7 +171,7 @@ function match(...matchers) {
             data = {
                 ...options?.extraFields,
                 ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-                ...((0, is_plain_object_js_1.isPlainObject)(raw) ? raw : null),
+                ...((0, primitives_js_1.isPlainObject)(raw) ? raw : null),
             };
         }
         else {

package/lib/primitives.d.ts

@@ -23,4 +23,5 @@ export declare function compactMap<T>(values: Record<string, T | undefined>): Re
 export declare function allRequired<V extends Record<string, unknown>>(v: V): {
     [K in keyof V]: NonNullable<V[K]>;
 } | undefined;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
 //# sourceMappingURL=primitives.d.ts.map

package/lib/primitives.js

@@ -9,6 +9,7 @@ exports.combineSignals = combineSignals;
 exports.abortSignalAny = abortSignalAny;
 exports.compactMap = compactMap;
 exports.allRequired = allRequired;
+exports.isPlainObject = isPlainObject;
 class InvariantError extends Error {
     constructor(message) {
         super(message);
@@ -108,4 +109,21 @@ function allRequired(v) {
     }
     return v;
 }
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    if (Object.prototype.toString.call(value) !== "[object Object]")
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null || proto === Object.prototype)
+        return true;
+    // cross-realm plain objects (vm contexts, iframes) inherit from a
+    // different realm's Object.prototype, which itself has a null prototype
+    try {
+        return Object.getPrototypeOf(proto) === null;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=primitives.js.map

package/lib/retries.js

@@ -132,6 +132,13 @@ async function retryBackoff(fn, strategy) {
     }
 }
 function retryIntervalFromResponse(res) {
+    const retryAfterMsVal = res.headers.get("retry-after-ms");
+    if (retryAfterMsVal) {
+        const parsedMs = Number(retryAfterMsVal);
+        if (Number.isFinite(parsedMs) && parsedMs >= 0) {
+            return parsedMs;
+        }
+    }
     const retryVal = res.headers.get("retry-after") || "";
     if (!retryVal) {
         return 0;

package/lib/sdks.d.ts

@@ -54,7 +54,7 @@ export declare class ClientSDK {
     _createRequest(context: HookContext, conf: RequestConfig, options?: RequestOptions): Result<Request, InvalidRequestError | UnexpectedClientError>;
     _do(request: Request, options: {
         context: HookContext;
-        errorCodes: number | string | (number | string)[];
+        isErrorStatusCode: (statusCode: number) => boolean;
         retryConfig: RetryConfig;
         retryCodes: string[];
     }): Promise<Result<Response, RequestAbortedError | RequestTimeoutError | ConnectionError | UnexpectedClientError>>;

package/lib/sdks.js

@@ -23,6 +23,7 @@ const base64_js_1 = require("./base64.js");
 const config_js_1 = require("./config.js");
 const encodings_js_1 = require("./encodings.js");
 const http_js_1 = require("./http.js");
+const primitives_js_1 = require("./primitives.js");
 const retries_js_1 = require("./retries.js");
 const gt = typeof globalThis === "undefined" ? null : globalThis;
 const webWorkerLike = typeof gt === "object"
@@ -65,26 +66,55 @@ class ClientSDK {
         if (!base) {
             return (0, fp_js_1.ERR)(new httpclienterrors_js_1.InvalidRequestError("No base URL provided for operation"));
         }
-        const reqURL = new URL(base);
-        const inputURL = new URL(path, reqURL);
+        const baseURL = new URL(base);
+        let reqURL;
         if (path) {
-            reqURL.pathname += reqURL.pathname.endsWith("/") ? "" : "/";
-            reqURL.pathname += inputURL.pathname.replace(/^\/+/, "");
-        }
-        let finalQuery = query || "";
-        const secQuery = [];
-        for (const [k, v] of Object.entries(security?.queryParams || {})) {
-            const q = (0, encodings_js_1.encodeForm)(k, v, { charEncoding: "percent" });
-            if (typeof q !== "undefined") {
-                secQuery.push(q);
+            baseURL.pathname = baseURL.pathname.replace(/\/+$/, "") + "/";
+            reqURL = new URL(path, baseURL);
+            if (!reqURL.search && baseURL.search) {
+                reqURL.search = baseURL.search;
             }
         }
-        if (secQuery.length) {
-            finalQuery += `&${secQuery.join("&")}`;
+        else {
+            reqURL = baseURL;
         }
+        reqURL.hash = "";
+        // Appends already-encoded query pairs to a query string, replacing any
+        // existing pairs with the same key so later sources take precedence.
+        const mergeQuery = (current, additions) => {
+            if (!additions) {
+                return current;
+            }
+            const additionKeys = new Set(additions
+                .split("&")
+                .filter((pair) => pair !== "")
+                .map((pair) => pair.split("=")[0] ?? ""));
+            const kept = current.split("&").filter((pair) => {
+                return pair !== "" && !additionKeys.has(pair.split("=")[0] ?? "");
+            });
+            return [...kept, additions].join("&");
+        };
+        const encodeQueryRecord = (record) => {
+            return Object.entries(record)
+                .map(([k, v]) => {
+                if (v == null) {
+                    return undefined;
+                }
+                const value = v;
+                return (0, encodings_js_1.encodeForm)(k, value, {
+                    explode: Array.isArray(value),
+                    charEncoding: "percent",
+                });
+            })
+                .filter((pair) => typeof pair !== "undefined")
+                .join("&");
+        };
+        const finalQuery = [
+            query || "",
+            encodeQueryRecord(security?.queryParams || {}),
+        ].reduce(mergeQuery, reqURL.search.slice(1));
         if (finalQuery) {
-            const q = finalQuery.startsWith("&") ? finalQuery.slice(1) : finalQuery;
-            reqURL.search = `?${q}`;
+            reqURL.search = `?${finalQuery}`;
         }
         const headers = new Headers(opHeaders);
         const username = security?.basic.username;
@@ -116,9 +146,8 @@ class ClientSDK {
             ...options?.fetchOptions,
             ...options,
         };
-        if (!fetchOptions?.signal && conf.timeoutMs && conf.timeoutMs > 0) {
-            const timeoutSignal = AbortSignal.timeout(conf.timeoutMs);
-            fetchOptions.signal = timeoutSignal;
+        if (!fetchOptions?.signal && conf.timeoutMs != null && conf.timeoutMs > 0) {
+            context.timeoutMs = conf.timeoutMs;
         }
         if (conf.body instanceof ReadableStream) {
             Object.assign(fetchOptions, { duplex: "half" });
@@ -143,13 +172,22 @@ class ClientSDK {
         return (0, fp_js_1.OK)(new Request(input.url, input.options));
     }
     async _do(request, options) {
-        const { context, errorCodes } = options;
+        const { context, isErrorStatusCode } = options;
+        const timeoutMs = context.timeoutMs;
         return (0, retries_js_1.retry)(async () => {
-            const req = await __classPrivateFieldGet(this, _ClientSDK_hooks, "f").beforeRequest(context, request.clone());
+            const cloned = request.clone();
+            let attempt = cloned;
+            if (timeoutMs != null && timeoutMs > 0) {
+                const timeoutSignal = AbortSignal.timeout(timeoutMs);
+                const combined = (0, primitives_js_1.combineSignals)(cloned.signal, timeoutSignal)
+                    ?? timeoutSignal;
+                attempt = new Request(cloned, { signal: combined });
+            }
+            const req = await __classPrivateFieldGet(this, _ClientSDK_hooks, "f").beforeRequest(context, attempt);
             await logRequest(__classPrivateFieldGet(this, _ClientSDK_logger, "f"), req).catch((e) => __classPrivateFieldGet(this, _ClientSDK_logger, "f")?.log("Failed to log request:", e));
             let response = await __classPrivateFieldGet(this, _ClientSDK_httpClient, "f").request(req);
             try {
-                if ((0, http_js_1.matchStatusCode)(response, errorCodes)) {
+                if (isErrorStatusCode(response.status)) {
                     const result = await __classPrivateFieldGet(this, _ClientSDK_hooks, "f").afterError(context, response, null);
                     if (result.error) {
                         throw result.error;
@@ -243,8 +281,6 @@ async function logResponse(logger, res, req) {
             break;
         case (0, http_js_1.matchContentType)(res, "application/jsonl")
             || jsonlLikeContentTypeRE.test(ct):
-            logger.log(await res.clone().text());
-            break;
         case (0, http_js_1.matchContentType)(res, "text/event-stream"):
             logger.log(`<${contentType}>`);
             break;

package/lib/security.d.ts

@@ -6,10 +6,11 @@ type OAuth2PasswordFlow = {
     clientSecret?: string | undefined;
     tokenURL: string;
 };
-export declare enum SecurityErrorCode {
-    Incomplete = "incomplete",
-    UnrecognisedSecurityType = "unrecognized_security_type"
-}
+export declare const SecurityErrorCode: {
+    readonly Incomplete: "incomplete";
+    readonly UnrecognisedSecurityType: "unrecognized_security_type";
+};
+export type SecurityErrorCode = (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
 export declare class SecurityError extends Error {
     code: SecurityErrorCode;
     constructor(code: SecurityErrorCode, message: string);
@@ -77,7 +78,7 @@ type SecurityInputCustom = {
 };
 export type SecurityInput = SecurityInputBasic | SecurityInputBearer | SecurityInputAPIKey | SecurityInputOAuth2 | SecurityInputOAuth2ClientCredentials | SecurityInputOAuth2PasswordCredentials | SecurityInputOIDC | SecurityInputCustom;
 export declare function resolveSecurity(...options: SecurityInput[][]): SecurityState | null;
-export declare function resolveGlobalSecurity(security: Partial<components.Security> | null | undefined): SecurityState | null;
+export declare function resolveGlobalSecurity(security: Partial<components.Security> | null | undefined, allowedFields?: number[]): SecurityState | null;
 export declare function extractSecurity<T extends string | Record<string, unknown>>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined>;
 export {};
 //# sourceMappingURL=security.d.ts.map

package/lib/security.js

@@ -7,11 +7,10 @@ exports.SecurityError = exports.SecurityErrorCode = void 0;
 exports.resolveSecurity = resolveSecurity;
 exports.resolveGlobalSecurity = resolveGlobalSecurity;
 exports.extractSecurity = extractSecurity;
-var SecurityErrorCode;
-(function (SecurityErrorCode) {
-    SecurityErrorCode["Incomplete"] = "incomplete";
-    SecurityErrorCode["UnrecognisedSecurityType"] = "unrecognized_security_type";
-})(SecurityErrorCode || (exports.SecurityErrorCode = SecurityErrorCode = {}));
+exports.SecurityErrorCode = {
+    Incomplete: "incomplete",
+    UnrecognisedSecurityType: "unrecognized_security_type",
+};
 class SecurityError extends Error {
     constructor(code, message) {
         super(message);
@@ -19,10 +18,10 @@ class SecurityError extends Error {
         this.name = "SecurityError";
     }
     static incomplete() {
-        return new SecurityError(SecurityErrorCode.Incomplete, "Security requirements not met in order to perform the operation");
+        return new SecurityError(exports.SecurityErrorCode.Incomplete, "Security requirements not met in order to perform the operation");
     }
     static unrecognizedType(type) {
-        return new SecurityError(SecurityErrorCode.UnrecognisedSecurityType, `Unrecognised security type: ${type}`);
+        return new SecurityError(exports.SecurityErrorCode.UnrecognisedSecurityType, `Unrecognised security type: ${type}`);
     }
 }
 exports.SecurityError = SecurityError;
@@ -101,8 +100,7 @@ function resolveSecurity(...options) {
                 applyBearer(state, spec);
                 break;
             default:
-                spec;
-                throw SecurityError.unrecognizedType(type);
+                throw SecurityError.unrecognizedType((spec, type));
         }
     });
     return state;
@@ -125,13 +123,24 @@ function applyBearer(state, spec) {
         state.headers[spec.fieldName] = value;
     }
 }
-function resolveGlobalSecurity(security) {
-    return resolveSecurity([
-        {
-            type: "http:basic",
-            value: { username: security?.username, password: security?.password },
-        },
-    ]);
+function resolveGlobalSecurity(security, allowedFields) {
+    let inputs = [
+        [
+            {
+                type: "http:basic",
+                value: { username: security?.username, password: security?.password },
+            },
+        ],
+    ];
+    if (allowedFields) {
+        inputs = allowedFields.map((i) => {
+            if (i < 0 || i >= inputs.length) {
+                throw new RangeError(`invalid allowedFields index ${i}`);
+            }
+            return inputs[i];
+        });
+    }
+    return resolveSecurity(...inputs);
 }
 async function extractSecurity(sec) {
     if (sec == null) {