@kontent-ai/core-sdk 10.2.0 → 10.3.1

package/lib/http/http.models.ts

@@ -1,83 +1,83 @@
-import { ResponseType } from 'axios';
-
-export interface IResponseRetryStrategyResult {
-    options: IRetryStrategyOptions;
-    retryAttempts: number;
-}
-
-export interface IResponse<TRawData> {
-    data: TRawData;
-    headers: IHeader[];
-    rawResponse: any;
-    status: number;
-    retryStrategy: IResponseRetryStrategyResult;
-}
-
-export interface IRetryStrategyOptions {
-    /**
-     * back-off interval between retries
-     */
-    deltaBackoffMs?: number;
-    /**
-     * Maximum allowed number of attempts
-     */
-    maxAttempts?: number;
-    /**
-     * Indicates if jitter is added to retry
-     */
-    addJitter?: boolean;
-    /**
-     * Determines if error can be retried. There are errors that are never retried
-     * such as when request is cancelled or the response status is 404 and so on...
-     */
-    canRetryError?: (error: any) => boolean;
-}
-
-export interface IHttpQueryCall {
-    url: string;
-}
-
-export interface IHttpPostQueryCall extends IHttpQueryCall {
-    body: any;
-}
-
-export interface IHttpPutQueryCall extends IHttpQueryCall {
-    body: any;
-}
-
-export interface IHttpPatchQueryCall extends IHttpQueryCall {
-    body: any;
-}
-
-export interface IHttpDeleteQueryCall extends IHttpQueryCall {}
-
-export interface IHttpGetQueryCall extends IHttpQueryCall {}
-
-export interface IHttpCancelRequestToken<TCancelToken> {
-    token: TCancelToken;
-    cancel: (cancelMessage?: string) => void;
-}
-
-export interface IHttpQueryOptions<TCancelToken> {
-    /**
-     * retry strategy
-     */
-    retryStrategy?: IRetryStrategyOptions;
-    /**
-     * Request headers
-     */
-    headers?: IHeader[];
-    /**
-     * Response type
-     */
-    responseType?: ResponseType;
-    /**
-     * Cancel token
-     */
-    cancelToken?: IHttpCancelRequestToken<TCancelToken>;
-}
-
-export interface IHeader {
-    header: string;
-    value: string;
-}
+import { ResponseType } from 'axios';
+
+export interface IResponseRetryStrategyResult {
+    options: IRetryStrategyOptions;
+    retryAttempts: number;
+}
+
+export interface IResponse<TRawData> {
+    data: TRawData;
+    headers: IHeader[];
+    rawResponse: any;
+    status: number;
+    retryStrategy: IResponseRetryStrategyResult;
+}
+
+export interface IRetryStrategyOptions {
+    /**
+     * back-off interval between retries
+     */
+    deltaBackoffMs?: number;
+    /**
+     * Maximum allowed number of attempts
+     */
+    maxAttempts?: number;
+    /**
+     * Indicates if jitter is added to retry
+     */
+    addJitter?: boolean;
+    /**
+     * Determines if error can be retried. There are errors that are never retried
+     * such as when request is cancelled or the response status is 404 and so on...
+     */
+    canRetryError?: (error: any) => boolean;
+}
+
+export interface IHttpQueryCall {
+    url: string;
+}
+
+export interface IHttpPostQueryCall extends IHttpQueryCall {
+    body: any;
+}
+
+export interface IHttpPutQueryCall extends IHttpQueryCall {
+    body: any;
+}
+
+export interface IHttpPatchQueryCall extends IHttpQueryCall {
+    body: any;
+}
+
+export interface IHttpDeleteQueryCall extends IHttpQueryCall {}
+
+export interface IHttpGetQueryCall extends IHttpQueryCall {}
+
+export interface IHttpCancelRequestToken<TCancelToken> {
+    token: TCancelToken;
+    cancel: (cancelMessage?: string) => void;
+}
+
+export interface IHttpQueryOptions<TCancelToken> {
+    /**
+     * retry strategy
+     */
+    retryStrategy?: IRetryStrategyOptions;
+    /**
+     * Request headers
+     */
+    headers?: IHeader[];
+    /**
+     * Response type
+     */
+    responseType?: ResponseType;
+    /**
+     * Cancel token
+     */
+    cancelToken?: IHttpCancelRequestToken<TCancelToken>;
+}
+
+export interface IHeader {
+    header: string;
+    value: string;
+}

package/lib/http/http.service.ts

@@ -1,91 +1,91 @@
-import axios, { AxiosInstance, AxiosRequestConfig, CancelToken } from 'axios';
-
-import * as HttpFunctions from './http.functions';
-import { IHttpFunctionsConfig } from './http.functions';
-import {
-    IResponse,
-    IHttpDeleteQueryCall,
-    IHttpGetQueryCall,
-    IHttpPatchQueryCall,
-    IHttpPostQueryCall,
-    IHttpPutQueryCall,
-    IHttpQueryOptions,
-    IHttpCancelRequestToken
-} from './http.models';
-import { IHttpService } from './ihttp.service';
-
-export class HttpService implements IHttpService<CancelToken> {
-    private readonly axiosInstance: AxiosInstance;
-
-    private readonly functionsConfig: IHttpFunctionsConfig;
-
-    constructor(
-        private opts?: {
-            axiosRequestConfig?: AxiosRequestConfig;
-            logErrorsToConsole?: boolean;
-        }
-    ) {
-        this.axiosInstance = axios.create(opts?.axiosRequestConfig);
-        this.functionsConfig = this.getFunctionsConfig();
-    }
-
-    async getAsync<TRawData>(
-        call: IHttpGetQueryCall,
-        options?: IHttpQueryOptions<CancelToken>
-    ): Promise<IResponse<TRawData>> {
-        return await HttpFunctions.getWithRetryAsync<TRawData>(this.axiosInstance, call, this.functionsConfig, options);
-    }
-
-    async postAsync<TRawData>(
-        call: IHttpPostQueryCall,
-        options?: IHttpQueryOptions<CancelToken>
-    ): Promise<IResponse<TRawData>> {
-        return await HttpFunctions.postWithRetryAsync<TRawData>(
-            this.axiosInstance,
-            call,
-            this.functionsConfig,
-            options
-        );
-    }
-
-    async putAsync<TRawData>(
-        call: IHttpPutQueryCall,
-        options?: IHttpQueryOptions<CancelToken>
-    ): Promise<IResponse<TRawData>> {
-        return await HttpFunctions.putWithRetryAsync<TRawData>(this.axiosInstance, call, this.functionsConfig, options);
-    }
-
-    async patchAsync<TRawData>(
-        call: IHttpPatchQueryCall,
-        options?: IHttpQueryOptions<CancelToken>
-    ): Promise<IResponse<TRawData>> {
-        return await HttpFunctions.patchWithRetryAsync<TRawData>(
-            this.axiosInstance,
-            call,
-            this.functionsConfig,
-            options
-        );
-    }
-
-    async deleteAsync<TRawData>(
-        call: IHttpDeleteQueryCall,
-        options?: IHttpQueryOptions<CancelToken>
-    ): Promise<IResponse<TRawData>> {
-        return await HttpFunctions.deleteWithRetryAsync<TRawData>(
-            this.axiosInstance,
-            call,
-            this.functionsConfig,
-            options
-        );
-    }
-
-    createCancelToken(): IHttpCancelRequestToken<CancelToken> {
-        return HttpFunctions.createCancelToken();
-    }
-
-    private getFunctionsConfig(): IHttpFunctionsConfig {
-        return {
-            logErrorsToConsole: this.opts?.logErrorsToConsole ?? true
-        };
-    }
-}
+import axios, { AxiosInstance, AxiosRequestConfig, CancelToken } from 'axios';
+
+import * as HttpFunctions from './http.functions';
+import { IHttpFunctionsConfig } from './http.functions';
+import {
+    IResponse,
+    IHttpDeleteQueryCall,
+    IHttpGetQueryCall,
+    IHttpPatchQueryCall,
+    IHttpPostQueryCall,
+    IHttpPutQueryCall,
+    IHttpQueryOptions,
+    IHttpCancelRequestToken
+} from './http.models';
+import { IHttpService } from './ihttp.service';
+
+export class HttpService implements IHttpService<CancelToken> {
+    private readonly axiosInstance: AxiosInstance;
+
+    private readonly functionsConfig: IHttpFunctionsConfig;
+
+    constructor(
+        private opts?: {
+            axiosRequestConfig?: AxiosRequestConfig;
+            logErrorsToConsole?: boolean;
+        }
+    ) {
+        this.axiosInstance = axios.create(opts?.axiosRequestConfig);
+        this.functionsConfig = this.getFunctionsConfig();
+    }
+
+    async getAsync<TRawData>(
+        call: IHttpGetQueryCall,
+        options?: IHttpQueryOptions<CancelToken>
+    ): Promise<IResponse<TRawData>> {
+        return await HttpFunctions.getWithRetryAsync<TRawData>(this.axiosInstance, call, this.functionsConfig, options);
+    }
+
+    async postAsync<TRawData>(
+        call: IHttpPostQueryCall,
+        options?: IHttpQueryOptions<CancelToken>
+    ): Promise<IResponse<TRawData>> {
+        return await HttpFunctions.postWithRetryAsync<TRawData>(
+            this.axiosInstance,
+            call,
+            this.functionsConfig,
+            options
+        );
+    }
+
+    async putAsync<TRawData>(
+        call: IHttpPutQueryCall,
+        options?: IHttpQueryOptions<CancelToken>
+    ): Promise<IResponse<TRawData>> {
+        return await HttpFunctions.putWithRetryAsync<TRawData>(this.axiosInstance, call, this.functionsConfig, options);
+    }
+
+    async patchAsync<TRawData>(
+        call: IHttpPatchQueryCall,
+        options?: IHttpQueryOptions<CancelToken>
+    ): Promise<IResponse<TRawData>> {
+        return await HttpFunctions.patchWithRetryAsync<TRawData>(
+            this.axiosInstance,
+            call,
+            this.functionsConfig,
+            options
+        );
+    }
+
+    async deleteAsync<TRawData>(
+        call: IHttpDeleteQueryCall,
+        options?: IHttpQueryOptions<CancelToken>
+    ): Promise<IResponse<TRawData>> {
+        return await HttpFunctions.deleteWithRetryAsync<TRawData>(
+            this.axiosInstance,
+            call,
+            this.functionsConfig,
+            options
+        );
+    }
+
+    createCancelToken(): IHttpCancelRequestToken<CancelToken> {
+        return HttpFunctions.createCancelToken();
+    }
+
+    private getFunctionsConfig(): IHttpFunctionsConfig {
+        return {
+            logErrorsToConsole: this.opts?.logErrorsToConsole ?? true
+        };
+    }
+}

package/lib/http/ihttp.service.ts

@@ -1,20 +1,20 @@
-import {
-  IResponse,
-  IHttpDeleteQueryCall,
-  IHttpGetQueryCall,
-  IHttpPostQueryCall,
-  IHttpPutQueryCall,
-  IHttpQueryOptions,
-  IHttpPatchQueryCall,
-  IHttpCancelRequestToken,
-} from './http.models';
-
-export interface IHttpService<TCancelToken> {
-  getAsync<TRawData>(call: IHttpGetQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
-  postAsync<TRawData>(call: IHttpPostQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
-  putAsync<TRawData>(call: IHttpPutQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
-  patchAsync<TRawData>(call: IHttpPatchQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
-  deleteAsync<TRawData>(call: IHttpDeleteQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
-
-  createCancelToken(): IHttpCancelRequestToken<TCancelToken>;
-}
+import {
+  IResponse,
+  IHttpDeleteQueryCall,
+  IHttpGetQueryCall,
+  IHttpPostQueryCall,
+  IHttpPutQueryCall,
+  IHttpQueryOptions,
+  IHttpPatchQueryCall,
+  IHttpCancelRequestToken,
+} from './http.models';
+
+export interface IHttpService<TCancelToken> {
+  getAsync<TRawData>(call: IHttpGetQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
+  postAsync<TRawData>(call: IHttpPostQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
+  putAsync<TRawData>(call: IHttpPutQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
+  patchAsync<TRawData>(call: IHttpPatchQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
+  deleteAsync<TRawData>(call: IHttpDeleteQueryCall, options?: IHttpQueryOptions<TCancelToken>): Promise<IResponse<TRawData>>;
+
+  createCancelToken(): IHttpCancelRequestToken<TCancelToken>;
+}

package/lib/http/index.ts

@@ -1,6 +1,6 @@
-export * from './ihttp.service';
-export * from './http.service';
-export * from './http.models';
-export * from './http.functions';
-export * from './http.debugger';
-export * from './test-http.service';
+export * from './ihttp.service';
+export * from './http.service';
+export * from './http.models';
+export * from './http.functions';
+export * from './http.debugger';
+export * from './test-http.service';

package/lib/http/test-http.service.ts

@@ -1,70 +1,70 @@
-import {
-    IResponse,
-    IHttpDeleteQueryCall,
-    IHttpGetQueryCall,
-    IHttpPatchQueryCall,
-    IHttpPostQueryCall,
-    IHttpPutQueryCall,
-    IHttpQueryOptions,
-    IHttpCancelRequestToken
-} from './http.models';
-import { IHttpService } from './ihttp.service';
-
-export class TestHttpService implements IHttpService<undefined> {
-    public response?: IResponse<any> = undefined;
-    public error?: any = undefined;
-
-    constructor(config: { response?: IResponse<any>; error?: any }) {
-        Object.assign(this, config);
-    }
-
-    getAsync<TRawData>(call: IHttpGetQueryCall, options?: IHttpQueryOptions<undefined>): Promise<IResponse<TRawData>> {
-        return this.resolveTestCall();
-    }
-
-    postAsync<TRawData>(
-        call: IHttpPostQueryCall,
-        options?: IHttpQueryOptions<undefined>
-    ): Promise<IResponse<TRawData>> {
-        return this.resolveTestCall();
-    }
-
-    putAsync<TRawData>(call: IHttpPutQueryCall, options?: IHttpQueryOptions<undefined>): Promise<IResponse<TRawData>> {
-        return this.resolveTestCall();
-    }
-
-    patchAsync<TRawData>(
-        call: IHttpPatchQueryCall,
-        options?: IHttpQueryOptions<undefined>
-    ): Promise<IResponse<TRawData>> {
-        return this.resolveTestCall();
-    }
-
-    deleteAsync<TRawData>(
-        call: IHttpDeleteQueryCall,
-        options?: IHttpQueryOptions<undefined>
-    ): Promise<IResponse<TRawData>> {
-        return this.resolveTestCall();
-    }
-
-    createCancelToken(): IHttpCancelRequestToken<undefined> {
-        return {
-            cancel: () => {},
-            token: undefined
-        };
-    }
-
-    private resolveTestCall(): Promise<IResponse<any>> {
-        const promise = new Promise<IResponse<any>>((resolve, reject) => {
-            if (this.response) {
-                resolve(this.response);
-            }
-            if (this.error) {
-                reject(this.error);
-            }
-
-            throw Error(`Missing test data`);
-        });
-        return promise;
-    }
-}
+import {
+    IResponse,
+    IHttpDeleteQueryCall,
+    IHttpGetQueryCall,
+    IHttpPatchQueryCall,
+    IHttpPostQueryCall,
+    IHttpPutQueryCall,
+    IHttpQueryOptions,
+    IHttpCancelRequestToken
+} from './http.models';
+import { IHttpService } from './ihttp.service';
+
+export class TestHttpService implements IHttpService<undefined> {
+    public response?: IResponse<any> = undefined;
+    public error?: any = undefined;
+
+    constructor(config: { response?: IResponse<any>; error?: any }) {
+        Object.assign(this, config);
+    }
+
+    getAsync<TRawData>(call: IHttpGetQueryCall, options?: IHttpQueryOptions<undefined>): Promise<IResponse<TRawData>> {
+        return this.resolveTestCall();
+    }
+
+    postAsync<TRawData>(
+        call: IHttpPostQueryCall,
+        options?: IHttpQueryOptions<undefined>
+    ): Promise<IResponse<TRawData>> {
+        return this.resolveTestCall();
+    }
+
+    putAsync<TRawData>(call: IHttpPutQueryCall, options?: IHttpQueryOptions<undefined>): Promise<IResponse<TRawData>> {
+        return this.resolveTestCall();
+    }
+
+    patchAsync<TRawData>(
+        call: IHttpPatchQueryCall,
+        options?: IHttpQueryOptions<undefined>
+    ): Promise<IResponse<TRawData>> {
+        return this.resolveTestCall();
+    }
+
+    deleteAsync<TRawData>(
+        call: IHttpDeleteQueryCall,
+        options?: IHttpQueryOptions<undefined>
+    ): Promise<IResponse<TRawData>> {
+        return this.resolveTestCall();
+    }
+
+    createCancelToken(): IHttpCancelRequestToken<undefined> {
+        return {
+            cancel: () => {},
+            token: undefined
+        };
+    }
+
+    private resolveTestCall(): Promise<IResponse<any>> {
+        const promise = new Promise<IResponse<any>>((resolve, reject) => {
+            if (this.response) {
+                resolve(this.response);
+            }
+            if (this.error) {
+                reject(this.error);
+            }
+
+            throw Error(`Missing test data`);
+        });
+        return promise;
+    }
+}

package/lib/index.ts

@@ -1,4 +1,4 @@
-/* Public API */
-export * from './helpers';
-export * from './models';
-export * from './http';
+/* Public API */
+export * from './helpers';
+export * from './models';
+export * from './http';

package/lib/models/index.ts

@@ -1,3 +1,3 @@
-export * from './url.models';
-export * from './isdk-info';
-export * from './parameters';
+export * from './url.models';
+export * from './isdk-info';
+export * from './parameters';

package/lib/models/isdk-info.ts

@@ -1,15 +1,15 @@
-export interface ISDKInfo {
-
-    /**
-     * Name of SDK
-     */
-    name: string;
-    /**
-     * Version SDK
-     */
-    version: string;
-    /**
-     * Host of SDK
-     */
-    host: string;
-}
+export interface ISDKInfo {
+
+    /**
+     * Name of SDK
+     */
+    name: string;
+    /**
+     * Version SDK
+     */
+    version: string;
+    /**
+     * Host of SDK
+     */
+    host: string;
+}

package/lib/models/parameters.ts

@@ -1,25 +1,25 @@
-import { IQueryParameter } from './url.models';
-
-export namespace Parameters {
-    export class CustomParameter implements IQueryParameter {
-        /**
-         * Custom parameter
-         * @constructor
-         * @param {string} name - Name of the parameter
-         * @param {string} value - Value of the parameter
-         */
-        constructor(public name: string, public value: string) {
-            if (!name) {
-                throw Error(`Name of the custom parameter is not specified`);
-            }
-        }
-
-        public getParam(): string {
-            return this.name;
-        }
-
-        public getParamValue(): string {
-            return this.value;
-        }
-    }
-}
+import { IQueryParameter } from './url.models';
+
+export namespace Parameters {
+    export class CustomParameter implements IQueryParameter {
+        /**
+         * Custom parameter
+         * @constructor
+         * @param {string} name - Name of the parameter
+         * @param {string} value - Value of the parameter
+         */
+        constructor(public name: string, public value: string) {
+            if (!name) {
+                throw Error(`Name of the custom parameter is not specified`);
+            }
+        }
+
+        public getParam(): string {
+            return this.name;
+        }
+
+        public getParamValue(): string {
+            return this.value;
+        }
+    }
+}

package/lib/models/url.models.ts

@@ -1,3 +1,3 @@
-export interface IQueryParameter {
-    getParam(): string;
-}
+export interface IQueryParameter {
+    getParam(): string;
+}

package/lib/sdk-info.generated.ts

@@ -2,6 +2,6 @@
 import { ISDKInfo } from '.';
 export const sdkInfo: ISDKInfo = {
     host: 'npmjs.com',
-    version: '10.2.0',
+    version: '10.3.1',
     name: '@kontent-ai/core-sdk'
 };