@leonardo-ai/sdk 4.14.2 → 4.15.0

package/src/lib/sdks.ts

@@ -2,15 +2,30 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import { ResponseMatcher, HTTPClient, matchStatusCode } from "./http.js";
-import { SecurityState, resolveSecurity, resolveGlobalSecurity } from "./security.js";
+import {
+    HTTPClient,
+    matchContentType,
+    matchStatusCode,
+    isAbortError,
+    isTimeoutError,
+    isConnectionError,
+} from "./http.js";
+import { SecurityState } from "./security.js";
 import { retry, RetryConfig } from "./retries.js";
-import { pathToFunc } from "./url.js";
+import { Logger } from "./logger.js";
 import { encodeForm } from "./encodings.js";
 import { stringToBase64 } from "./base64.js";
-import { SDK_METADATA } from "./config.js";
+import { SDKOptions, SDK_METADATA, serverURLFromOptions } from "./config.js";
 import { SDKHooks } from "../hooks/hooks.js";
 import { HookContext } from "../hooks/types.js";
+import {
+    ConnectionError,
+    InvalidRequestError,
+    RequestAbortedError,
+    RequestTimeoutError,
+    UnexpectedClientError,
+} from "../sdk/models/errors/httpclienterrors.js";
+import { ERR, OK, Result } from "../sdk/types/fp.js";
 
 export type RequestOptions = {
     /**
@@ -58,32 +73,49 @@ const isBrowserLike =
     (typeof window === "object" && typeof window.document !== "undefined");
 
 export class ClientSDK {
-    private readonly client: HTTPClient;
+    private readonly httpClient: HTTPClient;
     protected readonly baseURL: URL | null;
     protected readonly hooks$: SDKHooks;
+    protected readonly logger?: Logger | undefined;
+    public readonly options$: SDKOptions & { hooks?: SDKHooks };
 
-    constructor(init: { client: HTTPClient; baseURL: URL | null; hooks: SDKHooks }) {
-        const url = init.baseURL;
+    constructor(options: SDKOptions = {}) {
+        const opt = options as unknown;
+        if (
+            typeof opt === "object" &&
+            opt != null &&
+            "hooks" in opt &&
+            opt.hooks instanceof SDKHooks
+        ) {
+            this.hooks$ = opt.hooks;
+        } else {
+            this.hooks$ = new SDKHooks();
+        }
+        this.options$ = { ...options, hooks: this.hooks$ };
+
+        const url = serverURLFromOptions(options);
         if (url) {
             url.pathname = url.pathname.replace(/\/+$/, "") + "/";
         }
-
-        this.hooks$ = init.hooks;
-        const { baseURL, client } = this.hooks$.sdkInit({ baseURL: url, client: init.client });
+        const { baseURL, client } = this.hooks$.sdkInit({
+            baseURL: url,
+            client: options.httpClient || new HTTPClient(),
+        });
         this.baseURL = baseURL;
-        this.client = client;
+        this.httpClient = client;
+        this.logger = options.debugLogger;
     }
 
-    protected createRequest$(
+    public createRequest$(
         context: HookContext,
         conf: RequestConfig,
         options?: RequestOptions
-    ): Request {
+    ): Result<Request, InvalidRequestError | UnexpectedClientError> {
         const { method, path, query, headers: opHeaders, security } = conf;
 
         const base = conf.baseURL ?? this.baseURL;
         if (!base) {
-            throw new TypeError("No base URL provided for operation");
+            return ERR(new InvalidRequestError("No base URL provided for operation"));
         }
         const reqURL = new URL(base);
         const inputURL = new URL(path, reqURL);
@@ -149,20 +181,39 @@ export class ClientSDK {
             }
         }
 
-        const input = this.hooks$.beforeCreateRequest(context, {
-            url: reqURL,
-            options: {
-                ...fetchOptions,
-                body: conf.body ?? null,
-                headers,
-                method,
-            },
-        });
+        if (conf.body instanceof ReadableStream) {
+            if (!fetchOptions) {
+                fetchOptions = {
+                    // @ts-expect-error see https://github.com/node-fetch/node-fetch/issues/1769
+                    duplex: "half",
+                };
+            } else {
+                // @ts-expect-error see https://github.com/node-fetch/node-fetch/issues/1769
+                fetchOptions.duplex = "half";
+            }
+        }
 
-        return new Request(input.url, input.options);
+        let input;
+        try {
+            input = this.hooks$.beforeCreateRequest(context, {
+                url: reqURL,
+                options: {
+                    ...fetchOptions,
+                    body: conf.body ?? null,
+                    headers,
+                    method,
+                },
+            });
+        } catch (err: unknown) {
+            return ERR(
+                new UnexpectedClientError("Create request hook failed to execute", { cause: err })
+            );
+        }
+
+        return OK(new Request(input.url, input.options));
     }
 
-    protected async do$(
+    public async do$(
         request: Request,
         options: {
             context: HookContext;
@@ -170,19 +221,25 @@ export class ClientSDK {
             retryConfig?: RetryConfig | undefined;
             retryCodes?: string[] | undefined;
         }
-    ): Promise<Response> {
+    ): Promise<
+        Result<
+            Response,
+            RequestAbortedError | RequestTimeoutError | ConnectionError | UnexpectedClientError
+        >
+    > {
         const { context, errorCodes } = options;
         const retryConfig = options.retryConfig || { strategy: "none" };
         const retryCodes = options.retryCodes || [];
 
         return retry(
             async () => {
-                const req = request.clone();
-
-                let response = await this.client.request(
-                    await this.hooks$.beforeRequest(context, req)
+                const req = await this.hooks$.beforeRequest(context, request.clone());
+                await logRequest(this.logger, req).catch((e) =>
+                    this.logger?.log("Failed to log request:", e)
                 );
 
+                let response = await this.httpClient.request(req);
+
                 if (matchStatusCode(response, errorCodes)) {
                     const result = await this.hooks$.afterError(context, response, null);
                     if (result.error) {
@@ -193,18 +250,120 @@ export class ClientSDK {
                     response = await this.hooks$.afterSuccess(context, response);
                 }
 
+                await logResponse(this.logger, response, req).catch((e) =>
+                    this.logger?.log("Failed to log response:", e)
+                );
+
                 return response;
             },
             { config: retryConfig, statusCodes: retryCodes }
+        ).then(
+            (r) => OK(r),
+            (err) => {
+                switch (true) {
+                    case isAbortError(err):
+                        return ERR(
+                            new RequestAbortedError("Request aborted by client", { cause: err })
+                        );
+                    case isTimeoutError(err):
+                        return ERR(new RequestTimeoutError("Request timed out", { cause: err }));
+                    case isConnectionError(err):
+                        return ERR(new ConnectionError("Unable to make request", { cause: err }));
+                    default:
+                        return ERR(
+                            new UnexpectedClientError("Unexpected HTTP client error", {
+                                cause: err,
+                            })
+                        );
+                }
+            }
         );
     }
+}
+
+const jsonLikeContentTypeRE = /^application\/(?:.{0,100}\+)?json/;
+async function logRequest(logger: Logger | undefined, req: Request) {
+    if (!logger) {
+        return;
+    }
+
+    const contentType = req.headers.get("content-type");
+    const ct = contentType?.split(";")[0] || "";
+
+    logger.group(`> Request: ${req.method} ${req.url}`);
+
+    logger.group("Headers:");
+    for (const [k, v] of req.headers.entries()) {
+        logger.log(`${k}: ${v}`);
+    }
+    logger.groupEnd();
 
-    protected matcher<Result>(): ResponseMatcher<Result> {
-        return new ResponseMatcher<Result>();
+    logger.group("Body:");
+    switch (true) {
+        case jsonLikeContentTypeRE.test(ct):
+            logger.log(await req.clone().json());
+            break;
+        case ct.startsWith("text/"):
+            logger.log(await req.clone().text());
+            break;
+        case ct === "multipart/form-data": {
+            const body = await req.clone().formData();
+            for (const [k, v] of body) {
+                const vlabel = v instanceof Blob ? "<Blob>" : v;
+                logger.log(`${k}: ${vlabel}`);
+            }
+            break;
+        }
+        default:
+            logger.log(`<${contentType}>`);
+            break;
     }
+    logger.groupEnd();
+
+    logger.groupEnd();
+}
 
-    protected templateURLComponent = pathToFunc;
+async function logResponse(logger: Logger | undefined, res: Response, req: Request) {
+    if (!logger) {
+        return;
+    }
+
+    const contentType = res.headers.get("content-type");
+    const ct = contentType?.split(";")[0] || "";
+
+    logger.group(`< Response: ${req.method} ${req.url}`);
+    logger.log("Status Code:", res.status, res.statusText);
+
+    logger.group("Headers:");
+    for (const [k, v] of res.headers.entries()) {
+        logger.log(`${k}: ${v}`);
+    }
+    logger.groupEnd();
+
+    logger.group("Body:");
+    switch (true) {
+        case matchContentType(res, "application/json") || jsonLikeContentTypeRE.test(ct):
+            logger.log(await res.clone().json());
+            break;
+        case matchContentType(res, "text/event-stream"):
+            logger.log(`<${contentType}>`);
+            break;
+        case matchContentType(res, "text/*"):
+            logger.log(await res.clone().text());
+            break;
+        case matchContentType(res, "multipart/form-data"): {
+            const body = await res.clone().formData();
+            for (const [k, v] of body) {
+                const vlabel = v instanceof Blob ? "<Blob>" : v;
+                logger.log(`${k}: ${vlabel}`);
+            }
+            break;
+        }
+        default:
+            logger.log(`<${contentType}>`);
+            break;
+    }
+    logger.groupEnd();
 
-    protected resolveSecurity = resolveSecurity;
-    protected resolveGlobalSecurity = resolveGlobalSecurity;
+    logger.groupEnd();
 }

package/src/lib/security.ts

@@ -71,13 +71,20 @@ type SecurityInputOAuth2ClientCredentials = {
     fieldName: string;
 };
 
+type SecurityInputCustom = {
+    type: "http:custom";
+    value: any | null | undefined;
+    fieldName: string;
+};
+
 export type SecurityInput =
     | SecurityInputBasic
     | SecurityInputBearer
     | SecurityInputAPIKey
     | SecurityInputOAuth2
     | SecurityInputOAuth2ClientCredentials
-    | SecurityInputOIDC;
+    | SecurityInputOIDC
+    | SecurityInputCustom;
 
 export function resolveSecurity(...options: SecurityInput[][]): SecurityState | null {
     const state: SecurityState = {
@@ -93,6 +100,8 @@ export function resolveSecurity(...options: SecurityInput[][]): SecurityState |
                 return false;
             } else if (o.type === "http:basic") {
                 return o.value.username != null || o.value.password != null;
+            } else if (o.type === "http:custom") {
+                return null;
             } else if (typeof o.value === "string") {
                 return !!o.value;
             } else {
@@ -126,6 +135,8 @@ export function resolveSecurity(...options: SecurityInput[][]): SecurityState |
             case "http:basic":
                 applyBasic(state, spec);
                 break;
+            case "http:custom":
+                break;
             case "http:bearer":
                 applyBearer(state, spec);
                 break;
@@ -180,3 +191,13 @@ export function resolveGlobalSecurity(
         },
     ]);
 }
+
+export async function extractSecurity<T extends string | Record<string, unknown>>(
+    sec: T | (() => Promise<T>) | undefined
+): Promise<T | undefined> {
+    if (sec == null) {
+        return;
+    }
+
+    return typeof sec === "function" ? sec() : sec;
+}