@sitecore/sc-contenthub-webclient-sdk 0.9.7

package/dist/clients/entity-definitions-client.js

@@ -0,0 +1,354 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityDefinitionsClient = void 0;
+const HttpStatus = __importStar(require("http-status-codes"));
+const lodash_1 = require("lodash");
+const ta_json_1 = require("ta-json");
+const entity_definition_cache_1 = require("../caches/entity-definition-cache");
+const entity_definition_id_iterator_1 = require("../contracts/querying/entity-definition-id-iterator");
+const entity_definition_id_query_result_1 = require("../contracts/querying/entity-definition-id-query-result");
+const entity_definition_iterator_1 = require("../contracts/querying/entity-definition-iterator");
+const entity_definition_query_result_1 = require("../contracts/querying/entity-definition-query-result");
+const internal_error_1 = require("../errors/internal-error");
+const guard_1 = __importDefault(require("../guard"));
+const entity_definition_collection_resource_1 = require("../models/entity-definition-collection-resource");
+const entity_definition_resource_1 = require("../models/entity-definition-resource");
+const type_guards_1 = require("../type-guards");
+const response_handler_1 = require("./response-handler");
+class EntityDefinitionsClient {
+    constructor(client) {
+        this._client = client;
+        this._cache = new entity_definition_cache_1.EntityDefinitionCache();
+    }
+    getAllCachedAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let definitions = this._cache.getAll();
+            if (!definitions) {
+                definitions = yield this.getAllAsync();
+            }
+            return definitions;
+        });
+    }
+    getAllAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const allEntityDefinitions = yield this.getAllBatchedAsync();
+            this._cache.loadAll(allEntityDefinitions);
+            return allEntityDefinitions;
+        });
+    }
+    getAsync(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            const link = yield this._client.linkHelper.definitionToLinkAsync(param, true);
+            return this.getDefinitionAsync(link);
+        });
+    }
+    getCachedAsync(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            let definition = this._cache.get(param);
+            if (!definition) {
+                definition = yield this.getAsync(param);
+            }
+            return definition;
+        });
+    }
+    getNameAsync(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            const definition = yield this.getAsync(id);
+            return definition && definition.name;
+        });
+    }
+    getNameCachedAsync(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.validId(id);
+            let definition = this._cache.get(id);
+            if (!definition) {
+                definition = yield this.getAsync(id);
+            }
+            return definition && definition.name;
+        });
+    }
+    getIdAsync(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            const definition = yield this.getAsync(name);
+            return definition && definition.id;
+        });
+    }
+    getIdCachedAsync(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.stringNotNullOrEmpty(name);
+            let definition = this._cache.get(name);
+            if (!definition) {
+                definition = yield this.getAsync(name);
+            }
+            return definition && definition.id;
+        });
+    }
+    getManyAsync(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (param.length === 0) {
+                return [];
+            }
+            else if (type_guards_1.TypeGuards.isStringArray(param)) {
+                guard_1.default.arrayNoneNullOrEmptyString(param);
+                const linkFactory = (batch, batchSize, includeConditionalMembers) => this._client.linkHelper.definitionsToLinkAsync(batch, undefined, batchSize, includeConditionalMembers);
+                return this.getDefinitionsBatchedAsync(param, linkFactory);
+            }
+            else {
+                guard_1.default.validIds(param);
+                const linkFactory = (batch, batchSize, includeConditionalMembers) => this._client.linkHelper.definitionsToLinkAsync(batch, undefined, batchSize, includeConditionalMembers);
+                return this.getDefinitionsBatchedAsync(param, linkFactory);
+            }
+        });
+    }
+    getManyCachedAsync(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (param.length === 0)
+                return [];
+            const shouldGetByName = typeof param[0] === "string";
+            const stillToFetch = [];
+            const result = [];
+            for (const nameOrId of param) {
+                const definition = this._cache.get(nameOrId);
+                if (definition != null) {
+                    result.push(definition);
+                }
+                else {
+                    stillToFetch.push(nameOrId);
+                }
+            }
+            if (stillToFetch != null && stillToFetch.length > 0) {
+                const set = new Set(stillToFetch);
+                const fetchedDefinitions = yield this.getManyAsync(shouldGetByName ? [...set] : [...set]);
+                result.push(...fetchedDefinitions);
+            }
+            return result;
+        });
+    }
+    getNamesAsync(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(ids);
+            if (ids.length === 0)
+                return {};
+            guard_1.default.validIds(ids);
+            const definitions = yield this.getManyAsync(ids);
+            const result = {};
+            for (const definition of definitions) {
+                result[definition.id] = definition.name;
+            }
+            return result;
+        });
+    }
+    getNamesCachedAsync(ids) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(ids);
+            if (ids.length === 0)
+                return {};
+            guard_1.default.validIds(ids);
+            const definitions = yield this.getManyCachedAsync(ids);
+            const result = {};
+            for (const definition of definitions) {
+                result[definition.id] = definition.name;
+            }
+            return result;
+        });
+    }
+    getIdsAsync(names) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(names);
+            if (names.length === 0)
+                return {};
+            const definitions = yield this.getManyAsync(names);
+            const result = {};
+            for (const definition of definitions) {
+                result[definition.name] = definition.id;
+            }
+            return result;
+        });
+    }
+    getIdsCachedAsync(names) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(names);
+            if (names.length === 0)
+                return {};
+            const definitions = yield this.getManyCachedAsync(names);
+            const result = {};
+            for (const definition of definitions) {
+                result[definition.name] = definition.id;
+            }
+            return result;
+        });
+    }
+    saveAsync(definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(definition);
+            const resource = yield this._client.entityDefinitionMapper.mapEntityDefinitionResourceAsync(definition);
+            let response;
+            if (definition.isNew) {
+                const link = yield this._client.linkHelper.definitionsLinkAsync();
+                response = yield this._client.raw.postAsync(link.href, ta_json_1.TaJson.serialize(resource));
+            }
+            else {
+                const link = yield this._client.linkHelper.definitionToLinkAsync(definition.name);
+                response = yield this._client.raw.putAsync(link.href, ta_json_1.TaJson.serialize(resource));
+            }
+            response_handler_1.ResponseHandler.handleErrors(response);
+            let definitionId = 0;
+            if (definition.isNew) {
+                definitionId = (yield this.getIdAsync(definition.name)) || 0;
+            }
+            else {
+                definitionId = definition.id;
+                this._cache.invalidate(definitionId);
+            }
+            if (definitionId === 0) {
+                throw new internal_error_1.InternalError("Did not receive a valid id after saving.");
+            }
+            return definitionId;
+        });
+    }
+    deleteAsync(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNullOrUndefined(param);
+            if (typeof param === "string") {
+                guard_1.default.stringNotNullOrEmpty(param);
+            }
+            else {
+                guard_1.default.validId(param);
+            }
+            const link = yield this._client.linkHelper.definitionToLinkAsync(param);
+            const response = yield this._client.raw.deleteAsync(link.href);
+            response_handler_1.ResponseHandler.handleErrors(response);
+            this._cache.invalidate(param);
+        });
+    }
+    getRangeAsync(skip, take) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNegative(skip);
+            guard_1.default.notNegative(take);
+            const resource = yield this.getDefinitionsSkipTake(skip, take);
+            const definitions = yield this._client.entityDefinitionMapper.mapEntityDefinitionsAsync(resource);
+            for (const definition of definitions) {
+                this._cache.load(definition);
+            }
+            return new entity_definition_query_result_1.EntityDefinitionQueryResult(this._client, definitions, resource.totalItems || 0, skip);
+        });
+    }
+    getRangeIdsAsync(skip, take) {
+        return __awaiter(this, void 0, void 0, function* () {
+            guard_1.default.notNegative(skip);
+            guard_1.default.notNegative(take);
+            const result = yield this.getRangeAsync(skip, take);
+            return new entity_definition_id_query_result_1.EntityDefinitionIdQueryResult(this._client, result.items.map(item => item.id), result.totalNumberOfResults, skip);
+        });
+    }
+    createEntityDefinitionIterator(pageSize) {
+        return new entity_definition_iterator_1.EntityDefinitionIterator(this._client, pageSize);
+    }
+    createEntityDefinitionIdIterator(pageSize) {
+        return new entity_definition_id_iterator_1.EntityDefinitionIdIterator(this._client, pageSize);
+    }
+    getDefinitionsSkipTake(skip, take) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const link = yield this._client.linkHelper.definitionsToLinkAsync(null, skip, take, true);
+            const response = yield this._client.raw.getAsync(link.href);
+            const collectionResource = ta_json_1.TaJson.deserialize(response.content, entity_definition_collection_resource_1.EntityDefinitionCollectionResource);
+            return collectionResource;
+        });
+    }
+    getDefinitionAsync(link) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._client.raw.getAsync(link.href);
+            if (response.statusCode === HttpStatus.NOT_FOUND) {
+                return null;
+            }
+            const resource = ta_json_1.TaJson.deserialize(response.content, entity_definition_resource_1.EntityDefinitionResource);
+            const definition = yield this._client.entityDefinitionMapper.mapEntityDefinitionAsync(resource);
+            if (definition) {
+                this._cache.load(definition);
+            }
+            return definition;
+        });
+    }
+    getDefinitionsBatchedAsync(definitionsToFetch, linkFactory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!definitionsToFetch || definitionsToFetch.length === 0) {
+                return [];
+            }
+            const resources = [];
+            // We need to batch this or the backend will refuse to respond.
+            const batches = lodash_1.chunk(definitionsToFetch, EntityDefinitionsClient._batchSize);
+            for (const definitionBatch of batches) {
+                const link = yield linkFactory(definitionBatch, EntityDefinitionsClient._batchSize, true);
+                const response = yield this._client.raw.getAsync(link.href);
+                response_handler_1.ResponseHandler.handleErrors(response);
+                const resource = ta_json_1.TaJson.deserialize(response.content, entity_definition_collection_resource_1.EntityDefinitionCollectionResource);
+                resources.push(...resource.items);
+            }
+            const definitions = yield this._client.entityDefinitionMapper.mapEntityDefinitionsAsync(resources);
+            for (const definition of definitions) {
+                this._cache.load(definition);
+            }
+            return definitions;
+        });
+    }
+    getAllBatchedAsync() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const resources = [];
+            let resource = null;
+            let skip = 0;
+            while (resource == null || resource.next) {
+                const link = (_a = resource === null || resource === void 0 ? void 0 : resource.next) !== null && _a !== void 0 ? _a : (yield this._client.linkHelper.definitionsLinkAsync(skip, EntityDefinitionsClient._batchSize, true));
+                const response = yield this._client.raw.getAsync(link.href);
+                response_handler_1.ResponseHandler.handleErrors(response);
+                resource = ta_json_1.TaJson.deserialize(response.content, entity_definition_collection_resource_1.EntityDefinitionCollectionResource);
+                resources.push(...resource.items);
+                skip += (_b = resource.returnedItems) !== null && _b !== void 0 ? _b : resource.items.length;
+            }
+            const definitions = yield this._client.entityDefinitionMapper.mapEntityDefinitionsAsync(resources);
+            for (const definition of definitions) {
+                this._cache.load(definition);
+            }
+            return definitions;
+        });
+    }
+}
+exports.EntityDefinitionsClient = EntityDefinitionsClient;
+EntityDefinitionsClient._batchSize = 25;

package/dist/clients/extended-client.d.ts

@@ -0,0 +1,11 @@
+import { IRelationFactory } from "../factories/relation-factory";
+import { EntityDefinitionMapper } from "../mappers/entity-definition-mapper";
+import { EntityMapper } from "../mappers/entity-mapper";
+import { IInternalClient } from "./internal-client";
+import { IWebContentHubClient } from "./web-content-hub-client";
+export interface IExtendedContentHubClient extends IWebContentHubClient {
+    readonly internalClient: IInternalClient;
+    readonly relationFactory: IRelationFactory;
+    readonly entityMapper: EntityMapper;
+    readonly entityDefinitionMapper: EntityDefinitionMapper;
+}

package/dist/clients/extended-client.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/clients/internal-client.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="urijs" />
+import OAuthPasswordGrant from "../authentication/oauth-password-grant";
+import OAuthRefreshTokenGrant from "../authentication/oauth-refreshtoken-grant";
+import { MapStringTo } from "../base-types";
+import { RequestMessage } from "./request-message";
+import { ResponseMessage } from "./response-message";
+export interface IInternalClient {
+    /**
+     * Authenticate with the remote server.
+     *
+     * @remarks
+     * Should return true when authentication succeeded.
+     * Should return false or throw an error when authentication failed.
+     *
+     * @returns Promise resolving to a boolean indicating if authentication succeeded.
+     */
+    authenticateAsync(): Promise<boolean>;
+    /**
+     * Sends a request to the remote server and returns the server's response.
+     * @param requestGenerator - Function which returns a {@link RequestMessage}
+     */
+    sendAsync<T = unknown, K = unknown>(requestGenerator: () => RequestMessage<T>): Promise<ResponseMessage<K>>;
+    /**
+     * Set headers which will be send with every request.
+     * @param headers - The headers to send with every request
+     */
+    setRequestHeaders(headers: MapStringTo<string>): void;
+}
+export declare class InternalClient implements IInternalClient {
+    private _accessToken;
+    private _passwordGrant;
+    private _refreshTokenGrant;
+    private _isAuthenticated;
+    private _requestHeaders;
+    private readonly _client;
+    /**
+     * Indicates if we should authenticate with OAuth.
+     */
+    private get shouldAuthenticateWithOAuth();
+    constructor(baseUri: URI | string, oauthGrant?: OAuthPasswordGrant | OAuthRefreshTokenGrant);
+    authenticateAsync(): Promise<boolean>;
+    setRequestHeaders(headers: MapStringTo<string>): void;
+    private send_onFulfilled;
+    private send_onRejected;
+    sendAsync<T = any, K = any>(requestGenerator: () => RequestMessage<T>): Promise<ResponseMessage<K>>;
+}

package/dist/clients/internal-client.js

@@ -0,0 +1,240 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_extensions_1 = require("axios-extensions");
+const ta_json_1 = require("ta-json");
+const oauth_password_grant_1 = __importDefault(require("../authentication/oauth-password-grant"));
+const oauth_refreshtoken_grant_1 = __importDefault(require("../authentication/oauth-refreshtoken-grant"));
+const token_info_1 = require("../authentication/token-info");
+const authentication_error_1 = require("../errors/authentication-error");
+const invalid_operation_error_1 = require("../errors/invalid-operation-error");
+const guard_1 = __importDefault(require("../guard"));
+const http_method_1 = require("../http-method");
+const response_message_1 = require("./response-message");
+class InternalClient {
+    constructor(baseUri, oauthGrant) {
+        this._passwordGrant = null;
+        this._refreshTokenGrant = null;
+        this._requestHeaders = {};
+        guard_1.default.notNullOrUndefined(baseUri);
+        guard_1.default.notNull(oauthGrant);
+        const baseUrl = typeof baseUri === "string" ? baseUri : baseUri.href();
+        guard_1.default.stringNotNullOrEmpty(baseUrl);
+        this._client = axios_1.default.create({
+            baseURL: baseUrl,
+            adapter: axios_extensions_1.throttleAdapterEnhancer(axios_extensions_1.cacheAdapterEnhancer(axios_1.default.defaults.adapter, { enabledByDefault: false })),
+        });
+        if (oauthGrant instanceof oauth_password_grant_1.default) {
+            this._passwordGrant = oauthGrant;
+        }
+        else if (oauthGrant instanceof oauth_refreshtoken_grant_1.default) {
+            this._refreshTokenGrant = oauthGrant;
+        }
+        if (this.shouldAuthenticateWithOAuth) {
+            const createRefreshTokenResponseInterceptor = () => {
+                const responseInterceptor = this._client.interceptors.response.use((response) => response, (error) => {
+                    // Reject promise if usual error
+                    if (error.status !== 401) {
+                        return Promise.reject(error);
+                    }
+                    // When response code is 401, try to refresh the token.
+                    // Eject the interceptor so it doesn't loop in case the token refresh causes the 401 response.
+                    this._client.interceptors.response.eject(responseInterceptor);
+                    return this._client
+                        .request({
+                        url: "/oauth/token",
+                        method: "POST",
+                        transformRequest: [
+                            function (data, headers) {
+                                headers["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8";
+                                return Object.keys(data)
+                                    .reduce((d, k) => {
+                                    d.push(`${k}=${encodeURIComponent(data[k])}`);
+                                    return d;
+                                }, [])
+                                    .join("&");
+                            },
+                        ],
+                        data: ta_json_1.TaJson.serialize(this._refreshTokenGrant),
+                    })
+                        .then(response => {
+                        const tokenInfo = ta_json_1.TaJson.deserialize(response.data, token_info_1.TokenInfo);
+                        this._accessToken = tokenInfo.accessToken;
+                        this._refreshTokenGrant.refreshToken = tokenInfo.refreshToken;
+                        error.response.config.headers["Authorization"] = "Bearer " + tokenInfo.accessToken;
+                        return axios_1.default(error.response.config);
+                    })
+                        .catch(error => {
+                        this._isAuthenticated = false;
+                        throw error;
+                    })
+                        .finally(createRefreshTokenResponseInterceptor);
+                });
+            };
+            createRefreshTokenResponseInterceptor.bind(this);
+            createRefreshTokenResponseInterceptor();
+        }
+        else {
+            // No OAuthGrant specified, so we must be in the browser.
+            this._client.defaults.withCredentials = true; // Send the cookies with the requests.
+            this._isAuthenticated = true; // Let's assume we're already authenticated
+        }
+    }
+    /**
+     * Indicates if we should authenticate with OAuth.
+     */
+    get shouldAuthenticateWithOAuth() {
+        return !!(this._passwordGrant || this._refreshTokenGrant);
+    }
+    authenticateAsync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._isAuthenticated || !this.shouldAuthenticateWithOAuth) {
+                return true;
+            }
+            if (this._accessToken) {
+                return true;
+            }
+            if (!this._passwordGrant) {
+                throw new invalid_operation_error_1.InvalidOperationError("Can not authenticate - Missing OAuth password grant.");
+            }
+            return yield this._client
+                .request({
+                url: "/oauth/token",
+                method: "POST",
+                transformRequest: [
+                    function (data, headers) {
+                        headers["Content-Type"] = "application/x-www-form-urlencoded; charset=UTF-8";
+                        return Object.keys(data)
+                            .reduce((d, k) => {
+                            d.push(`${k}=${encodeURIComponent(data[k])}`);
+                            return d;
+                        }, [])
+                            .join("&");
+                    },
+                ],
+                data: ta_json_1.TaJson.serialize(this._passwordGrant),
+            })
+                .then(response => {
+                const tokenInfo = ta_json_1.TaJson.deserialize(response.data, token_info_1.TokenInfo);
+                this._accessToken = tokenInfo.accessToken;
+                this._refreshTokenGrant = new oauth_refreshtoken_grant_1.default(this._passwordGrant.clientId, this._passwordGrant.clientSecret, tokenInfo.refreshToken);
+                this._client.interceptors.request.use(config => {
+                    config.headers["Authorization"] = `Bearer ${this._accessToken}`;
+                    return config;
+                }, error => {
+                    return Promise.reject(error);
+                });
+                this._isAuthenticated = true;
+                return true;
+            })
+                .catch(error => {
+                this._isAuthenticated = false;
+                throw new authentication_error_1.AuthenticationError("Authentication failed.", error);
+            });
+        });
+    }
+    setRequestHeaders(headers) {
+        guard_1.default.notNullOrUndefined(headers);
+        this._requestHeaders = headers;
+    }
+    send_onFulfilled(requestMsg) {
+        return (response) => {
+            return response_message_1.ResponseMessage.build(response.status, response.headers, {
+                requestMessage: Object.freeze(requestMsg),
+                content: response.data,
+                statusText: response.statusText,
+            });
+        };
+    }
+    send_onRejected(error) {
+        if (error.response) {
+            return response_message_1.ResponseMessage.build(error.response.status, error.response.headers, {
+                statusText: error.response.statusText,
+                content: error.response.data,
+            });
+        }
+        else if (error.request) {
+            return response_message_1.ResponseMessage.build(error.request.status, {}, { statusText: error.request.statusText, content: error.request.data });
+        }
+        else {
+            throw error;
+        }
+    }
+    sendAsync(requestGenerator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._isAuthenticated) {
+                throw new invalid_operation_error_1.InvalidOperationError("Client is not authenticated. Authenticate first.");
+            }
+            guard_1.default.notNullOrUndefined(requestGenerator);
+            const requestMsg = requestGenerator();
+            guard_1.default.notNullOrUndefined(requestMsg.requestUri);
+            const requestUrl = typeof requestMsg.requestUri === "string" ? requestMsg.requestUri : requestMsg.requestUri.href();
+            guard_1.default.stringNotNullOrEmpty(requestUrl);
+            const requestConfig = {};
+            requestConfig.headers = Object.assign(Object.assign({}, this._requestHeaders), requestMsg.requestHeaders);
+            let result = response_message_1.ResponseMessage.build(0); // Not a valid status code, but we'll know it failed.
+            switch (requestMsg.method) {
+                case http_method_1.HttpMethod.DELETE:
+                    result = yield this._client
+                        .delete(requestUrl, requestConfig)
+                        .then(this.send_onFulfilled(requestMsg), error => this.send_onRejected(error));
+                    break;
+                case http_method_1.HttpMethod.GET:
+                    result = yield this._client
+                        .get(requestUrl, requestConfig)
+                        .then(this.send_onFulfilled(requestMsg), error => this.send_onRejected(error));
+                    break;
+                case http_method_1.HttpMethod.HEAD:
+                    result = yield this._client
+                        .head(requestUrl, requestConfig)
+                        .then(this.send_onFulfilled(requestMsg), error => this.send_onRejected(error));
+                    break;
+                case http_method_1.HttpMethod.OPTIONS:
+                    requestConfig.method = "OPTIONS";
+                    requestConfig.url = requestUrl;
+                    result = yield this._client
+                        .request(requestConfig)
+                        .then(this.send_onFulfilled(requestMsg), error => this.send_onRejected(error));
+                    break;
+                case http_method_1.HttpMethod.PATCH:
+                    result = yield this._client
+                        .patch(requestUrl, typeof requestMsg.content === "string"
+                        ? requestMsg.content
+                        : ta_json_1.TaJson.serialize(requestMsg.content), requestConfig)
+                        .then(this.send_onFulfilled(requestMsg), error => this.send_onRejected(error));
+                    break;
+                case http_method_1.HttpMethod.POST:
+                    result = yield this._client
+                        .post(requestUrl, typeof requestMsg.content === "string"
+                        ? requestMsg.content
+                        : ta_json_1.TaJson.serialize(requestMsg.content), requestConfig)
+                        .then(this.send_onFulfilled(requestMsg), error => this.send_onRejected(error));
+                    break;
+                case http_method_1.HttpMethod.PUT:
+                    result = yield this._client
+                        .put(requestUrl, typeof requestMsg.content === "string"
+                        ? requestMsg.content
+                        : ta_json_1.TaJson.serialize(requestMsg.content), requestConfig)
+                        .then(this.send_onFulfilled(requestMsg), error => this.send_onRejected(error));
+                    break;
+                default:
+                    throw "Method not supported.";
+            }
+            return result;
+        });
+    }
+}
+exports.InternalClient = InternalClient;