@kontent-ai/core-sdk 10.0.0-0

package/lib/http/http.models.ts

@@ -0,0 +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;
+}

package/lib/http/http.service.ts

@@ -0,0 +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
+        };
+    }
+}

package/lib/http/ihttp.service.ts

@@ -0,0 +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>;
+}

package/lib/http/index.ts

@@ -0,0 +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';

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

@@ -0,0 +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;
+    }
+}

package/lib/index.ts

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

package/lib/models/index.ts

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

package/lib/models/isdk-info.ts

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

package/lib/models/parameters.ts

@@ -0,0 +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;
+        }
+    }
+}

package/lib/models/url.models.ts

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

package/lib/sdk-info.generated.ts

@@ -0,0 +1,7 @@
+
+import { ISDKInfo } from '.';
+export const sdkInfo: ISDKInfo = {
+    host: 'npmjs.com',
+    version: '10.0.0-0',
+    name: '@kontent-ai/core-sdk'
+};

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@kontent-ai/core-sdk",
+  "version": "10.0.0-0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kontent-ai/kontent-core-js"
+  },
+  "private": false,
+  "author": "richard sustek",
+  "license": "MIT",
+  "description": "Core package with shared / common functionality for Kontent.ai SDKs",
+  "keywords": [
+    "Kontent.ai",
+    "Kontent AI",
+    "Kontent SDK Core"
+  ],
+  "engines": {
+    "node": ">= 8"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/es5/index.js",
+  "es2015": "./dist/es2015/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "standard-version": {
+    "scripts": {
+      "postchangelog": "npm run set-sdk-version"
+    }
+  },
+  "scripts": {
+    "release": "standard-version",
+    "release:major": "npm run ts-lint:check && standard-version --release-as major",
+    "release:major:beta": "npm run ts-lint:check && standard-version --prerelease --release-as major",
+    "release:beta": "standard-version --prerelease",
+    "ts-lint:fix": "tslint --project ./tsconfig.json --fix",
+    "ts-lint:check": "tslint --project ./tsconfig.json",
+    "test:node": "npm run build:cjs && mocha -- \"test/node/**/*.js\" --timeout 15000",
+    "test:browser": "karma start karma.conf.js",
+    "test:dev": "karma start karma-dev.conf.js",
+    "test:ci": "karma start karma-ci.conf.js",
+    "test:all": "npm run test:node && npm run test:ci",
+    "new-patch": "npm version patch && npm run set-sdk-version && npm run check-version",
+    "new-minor": "npm version minor && npm run set-sdk-version && npm run check-version",
+    "new-major": "npm version major && npm run set-sdk-version && npm run check-version",
+    "prepublishOnly": "npm run ts-lint:check && npm run check-version && npm run build:all && npm run test:all",
+    "webpack:dev": "webpack --mode development --config webpack.config.js --progress",
+    "webpack:prod": "webpack  --mode production --config webpack.config.js --progress",
+    "set-sdk-version": "node ./misc/set-sdk-version.js",
+    "check-version": "ts-node ./misc/verify-sdk-version.ts",
+    "publish:beta": "npm publish --tag=next",
+    "build:umd": "npm run webpack:dev && npm run webpack:prod",
+    "build:es2015": "tsc --p tsconfig.es2015.json",
+    "build:es5": "tsc --p tsconfig.es5.json",
+    "build:cjs": "tsc --p tsconfig.cjs.json",
+    "build:all": "npm run build:umd && npm run build:cjs && npm run build:es5 && npm run build:es2015",
+    "bundle-stats:min": "npm run build:umd && webpack-bundle-analyzer dist/_bundles/stats.min.json",
+    "bundle-stats": "npm run build:umd && webpack-bundle-analyzer dist/_bundles/stats.json"
+  },
+  "dependencies": {
+    "axios": "0.27.2"
+  },
+  "devDependencies": {
+    "@types/jasmine": "4.0.3",
+    "@types/node": "18.0.3",
+    "colors": "1.4.0",
+    "core-js": "3.23.4",
+    "jasmine-core": "4.2.0",
+    "jasmine-spec-reporter": "7.0.0",
+    "karma": "6.4.0",
+    "karma-chrome-launcher": "3.1.1",
+    "karma-cli": "2.0.0",
+    "karma-jasmine": "5.1.0",
+    "karma-jasmine-html-reporter": "2.0.0",
+    "karma-sourcemap-loader": "0.3.8",
+    "karma-typescript": "5.5.3",
+    "karma-typescript-es6-transform": "5.5.3",
+    "karma-webpack": "5.0.0",
+    "mocha": "10.0.0",
+    "standard-version": "9.5.0",
+    "ts-loader": "9.3.1",
+    "ts-node": "10.8.2",
+    "tslint": "6.1.3",
+    "typescript": "4.7.4",
+    "webpack": "5.73.0",
+    "webpack-bundle-analyzer": "4.5.0",
+    "webpack-cli": "4.10.0"
+  }
+}