@squidcloud/client 1.0.181 → 1.0.182

package/dist/cjs/index.js

@@ -50387,21 +50387,15 @@ class RpcError extends Error {
  * Runs a post request to the given URL.
  * @internal.
  */
-async function rawSquidHttpPost({ url, headers, files, filesFieldName, message, extractErrorMessage, }) {
+async function rawSquidHttpPost(input) {
     // Native fetch is used in json request mode or when the corresponding private Squid option is enabled.
     // This option is enabled in console-local and console-dev modes both in Web & Backend.
-    const isFetch = files.length === 0 || !!getSquidPrivateOption(SQUID_PRIVATE_OPTION_USE_FETCH_IN_RPC_MANAGER);
-    let response;
-    if (isFetch) {
-        response = await performFetchRequest(headers, files, filesFieldName, message, url, extractErrorMessage);
-    }
-    else {
-        response = await performAxiosRequest(files, filesFieldName, message, url, headers, extractErrorMessage);
-    }
+    const isFetch = input.files.length === 0 || !!getSquidPrivateOption(SQUID_PRIVATE_OPTION_USE_FETCH_IN_RPC_MANAGER);
+    const response = await (isFetch ? performFetchRequest(input) : await performAxiosRequest(input));
     response.body = tryDeserializing(response.body);
     return response;
 }
-async function performFetchRequest(headers, files, filesFieldName, body, url, extractErrorMessage) {
+async function performFetchRequest({ headers, files, filesFieldName, message: body, url, extractErrorMessage, }) {
     const requestOptionHeaders = new Headers(headers);
     const requestOptions = { method: 'POST', headers: requestOptionHeaders, body: undefined };
     if (files.length) {
@@ -50431,7 +50425,7 @@ async function performFetchRequest(headers, files, filesFieldName, body, url, ex
         }
         let message;
         try {
-            message = typeof parsedBody === 'string' ? parsedBody : parsedBody['message'] || rawBody;
+            message = typeof parsedBody === 'string' ? parsedBody : (parsedBody === null || parsedBody === void 0 ? void 0 : parsedBody['message']) || rawBody;
         }
         catch (_a) { }
         if (!message)
@@ -50453,7 +50447,7 @@ function extractAxiosResponseHeaders(response) {
         return acc;
     }, {});
 }
-async function performAxiosRequest(files, filesFieldName, body, url, headers, extractErrorMessage) {
+async function performAxiosRequest({ files, filesFieldName, message: body, url, headers, extractErrorMessage, }) {
     let axiosResponse;
     try {
         if (files.length) {
@@ -50490,7 +50484,7 @@ async function performAxiosRequest(files, filesFieldName, body, url, headers, ex
             }
             let message;
             try {
-                message = typeof parsedBody === 'string' ? parsedBody : parsedBody['message'] || rawBody;
+                message = typeof parsedBody === 'string' ? parsedBody : (parsedBody === null || parsedBody === void 0 ? void 0 : parsedBody['message']) || rawBody;
             }
             catch (_a) { }
             if (!message)
@@ -50529,7 +50523,7 @@ function tryDeserializing(text) {
 
 
 class RpcManager {
-    constructor(region, appId, destructManager, headers = {}, authManager, clientIdService) {
+    constructor(region, appId, destructManager, headers, authManager, clientIdService) {
         this.region = region;
         this.appId = appId;
         this.authManager = authManager;

package/dist/internal-common/src/public-types/api-call.public-context.d.ts

@@ -26,10 +26,10 @@ export interface CallApiOptions {
      */
     originOverride?: string;
 }
-export interface CallApiRequest {
+export interface CallApiRequest<BodyType = any> {
     integrationId: IntegrationId;
     endpointId: ApiEndpointId;
-    body?: any;
+    body?: BodyType;
     overrideMethod?: HttpMethod;
     options: ApiOptions;
 }

package/dist/typescript-client/src/api-client.d.ts

@@ -4,17 +4,17 @@ import { ApiOptions } from '../../internal-common/src/public-types/api-call.publ
 import { HttpResponse } from './squid-http-client';
 export declare class ApiClient {
     private readonly rpcManager;
-    get<T = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, options?: ApiOptions): Promise<HttpResponse<T>>;
-    post<T = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: unknown, options?: ApiOptions): Promise<HttpResponse<T>>;
-    delete<T = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: unknown, options?: ApiOptions): Promise<HttpResponse<T>>;
-    patch<T = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: unknown, options?: ApiOptions): Promise<HttpResponse<T>>;
-    put<T = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: unknown, options?: ApiOptions): Promise<HttpResponse<T>>;
+    get<ResponseBodyType = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, options?: ApiOptions): Promise<HttpResponse<ResponseBodyType>>;
+    post<ResponseBodyType = unknown, RequestBodyType = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: RequestBodyType, options?: ApiOptions): Promise<HttpResponse<ResponseBodyType>>;
+    delete<ResponseBodyType = unknown, RequestBodyType = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: RequestBodyType, options?: ApiOptions): Promise<HttpResponse<ResponseBodyType>>;
+    patch<ResponseBodyType = unknown, RequestBodyType = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: RequestBodyType, options?: ApiOptions): Promise<HttpResponse<ResponseBodyType>>;
+    put<ResponseBodyType = unknown, RequestBodyType = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: RequestBodyType, options?: ApiOptions): Promise<HttpResponse<ResponseBodyType>>;
     /**
      * Performs an HTTP API request to the given integration ID and endpoint ID.
      * The provided options will be merged with the default options.
      * In case of error (status code >= 400 or other error), the promise will be rejected with an RpcError.
      */
-    request<T = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: unknown, options?: ApiOptions, method?: HttpMethod): Promise<HttpResponse<T>>;
+    request<ResponseBodyType = unknown, RequestBodyType = unknown>(integrationId: IntegrationId, endpointId: ApiEndpointId, body?: RequestBodyType, options?: ApiOptions, method?: HttpMethod): Promise<HttpResponse<ResponseBodyType>>;
     private convertOptionsToStrings;
     private convertToStrings;
 }

package/dist/typescript-client/src/rpc.manager.d.ts

@@ -12,13 +12,13 @@ export declare class RpcManager {
     private readonly staticHeaders;
     private readonly onGoingRpcCounter;
     private readonly rateLimiters;
-    constructor(region: SquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string> | undefined, authManager: AuthManager, clientIdService: ClientIdService);
+    constructor(region: SquidRegion, appId: string, destructManager: DestructManager, headers: Record<string, string>, authManager: AuthManager, clientIdService: ClientIdService);
     private getAuthHeaders;
     awaitAllSettled(): Promise<void>;
     setStaticHeader(key: string, value: string): void;
     deleteStaticHeader(key: string): void;
     getStaticHeaders(): Record<string, string>;
-    post<T>(path: string, message: unknown, files?: Array<File | BlobAndFilename>, filesFieldName?: string): Promise<T>;
-    rawPost<T = unknown>(path: string, message: unknown, files?: Array<File | BlobAndFilename>, filesFieldName?: string, extractErrorMessage?: boolean): Promise<HttpResponse<T>>;
+    post<ResponseType = unknown, RequestType = unknown>(path: string, message: RequestType, files?: Array<File | BlobAndFilename>, filesFieldName?: string): Promise<ResponseType>;
+    rawPost<ResponseType = unknown, RequestType = unknown>(path: string, message: RequestType, files?: Array<File | BlobAndFilename>, filesFieldName?: string, extractErrorMessage?: boolean): Promise<HttpResponse<ResponseType>>;
     private getRateLimiterBucket;
 }

package/dist/typescript-client/src/squid-http-client.d.ts

@@ -1,23 +1,23 @@
 import { BlobAndFilename } from './types';
-export declare class RpcError extends Error {
+export declare class RpcError<BodyType = unknown> extends Error {
     readonly statusCode: number;
     readonly statusText: string;
     readonly url: string;
     readonly headers: Record<string, string>;
-    readonly body?: unknown;
+    readonly body: BodyType;
 }
-export interface HttpPostInput {
+export interface HttpPostInput<RequestBodyType = unknown> {
     url: string;
     headers: Record<string, string>;
-    message: unknown;
+    message: RequestBodyType;
     files: Array<File | BlobAndFilename>;
     filesFieldName: string;
     extractErrorMessage: boolean;
 }
 /** A response object with type T for the body. */
-export interface HttpResponse<T = unknown> {
+export interface HttpResponse<BodyType = unknown> {
     status: number;
     statusText: string;
     headers: Record<string, string>;
-    body: T;
+    body: BodyType;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/client",
-  "version": "1.0.181",
+  "version": "1.0.182",
   "description": "A typescript implementation of the Squid client",
   "main": "dist/cjs/index.js",
   "types": "dist/typescript-client/src/index.d.ts",