@microsoft/kiota-abstractions
Version:
Core abstractions for kiota generated libraries in TypeScript and JavaScript
220 lines • 13.1 kB
JavaScript
/**
* -------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All Rights Reserved. Licensed under the MIT License.
* See License in the project root for license information.
* -------------------------------------------------------------------------------------------
*/
import { getPathParameters } from "./getPathParameters.js";
import { HttpMethod } from "./httpMethod.js";
import { RequestInformation } from "./requestInformation.js";
const sanitizeMethodName = (methodName) => {
if (methodName.startsWith("to")) {
return methodName.substring(2).replace("RequestInformation", "").toLowerCase();
}
return methodName;
};
const getRequestMethod = (key) => {
switch (sanitizeMethodName(key)) {
case "delete":
return "delete";
case "get":
return "get";
case "head":
return "head";
case "options":
return "options";
case "patch":
return "patch";
case "post":
return "post";
case "put":
return "put";
default:
return undefined;
}
};
// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
const toRequestInformation = (urlTemplate, pathParameters, metadata, requestAdapter, httpMethod, body, bodyMediaType, requestConfiguration) => {
const requestInfo = new RequestInformation(httpMethod, urlTemplate, pathParameters);
requestInfo.configure(requestConfiguration, metadata.queryParametersMapper);
addAcceptHeaderIfPresent(metadata, requestInfo);
if (metadata.requestBodySerializer) {
if (!body)
throw new Error("body cannot be undefined");
if (typeof metadata.requestBodySerializer === "function") {
requestInfo.setContentFromParsable(requestAdapter, metadata.requestBodyContentType ? metadata.requestBodyContentType : bodyMediaType, body, metadata.requestBodySerializer);
}
else {
requestInfo.setContentFromScalar(requestAdapter, metadata.requestBodyContentType ? metadata.requestBodyContentType : bodyMediaType, body);
}
}
else if (metadata.requestInformationContentSetMethod === "setStreamContent") {
if (!body)
throw new Error("body cannot be undefined");
requestInfo.setStreamContent(body, metadata.requestBodyContentType ? metadata.requestBodyContentType : bodyMediaType);
}
return requestInfo;
};
const addAcceptHeaderIfPresent = (metadata, requestInfo) => {
if (metadata.responseBodyContentType) {
requestInfo.headers.tryAdd("Accept", metadata.responseBodyContentType);
}
};
const getRequestMediaTypeUserDefinedValue = (requestMetadata, args) => {
if (args.length > 2 && !requestMetadata.requestBodySerializer && requestMetadata.requestInformationContentSetMethod === "setStreamContent" && typeof args[1] === "string") {
// request body with unknown media type so we have an argument for it.
return args[1];
}
return undefined;
};
const getRequestConfigurationValue = (args) => {
if (args.length > 0) {
// request configuration is always the last argument
return args[args.length - 1];
}
return undefined;
};
const send = (requestAdapter, requestInfo, metadata) => {
switch (metadata.adapterMethodName) {
case "send":
if (!metadata.responseBodyFactory) {
throw new Error("couldn't find response body factory");
}
return requestAdapter.send(requestInfo, metadata.responseBodyFactory, metadata.errorMappings);
case "sendCollection":
if (!metadata.responseBodyFactory) {
throw new Error("couldn't find response body factory");
}
return requestAdapter.sendCollection(requestInfo, metadata.responseBodyFactory, metadata.errorMappings);
case "sendEnum":
if (!metadata.enumObject) {
throw new Error("couldn't find response body factory");
}
return requestAdapter.sendEnum(requestInfo, metadata.enumObject, metadata.errorMappings);
case "sendCollectionOfEnum":
if (!metadata.enumObject) {
throw new Error("couldn't find response body factory");
}
return requestAdapter.sendCollectionOfEnum(requestInfo, metadata.enumObject, metadata.errorMappings);
case "sendCollectionOfPrimitive":
if (!metadata.responseBodyFactory) {
throw new Error("couldn't find response body factory");
}
return requestAdapter.sendCollectionOfPrimitive(requestInfo, metadata.responseBodyFactory, metadata.errorMappings);
case "sendPrimitive":
if (!metadata.responseBodyFactory) {
throw new Error("couldn't find response body factory");
}
return requestAdapter.sendPrimitive(requestInfo, metadata.responseBodyFactory, metadata.errorMappings);
case "sendNoResponseContent":
return requestAdapter.sendNoResponseContent(requestInfo, metadata.errorMappings);
default:
throw new Error("couldn't find adapter method");
}
};
export const apiClientProxifier = (requestAdapter, pathParameters, navigationMetadata, requestsMetadata) => {
if (!requestAdapter)
throw new Error("requestAdapter cannot be undefined");
if (!pathParameters)
throw new Error("pathParameters cannot be undefined");
return new Proxy({}, {
get: (_, property) => {
const name = String(property);
if (name === "withUrl") {
return (rawUrl) => {
if (!rawUrl)
throw new Error("rawUrl cannot be undefined");
return apiClientProxifier(requestAdapter, getPathParameters(rawUrl), navigationMetadata, requestsMetadata);
};
}
if (requestsMetadata) {
const metadataKey = getRequestMethod(name);
if (metadataKey) {
const metadata = requestsMetadata[metadataKey];
if (metadata) {
switch (name) {
case "get":
return (requestConfiguration) => {
const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.GET, undefined, undefined, requestConfiguration);
return send(requestAdapter, requestInfo, metadata);
};
case "patch":
return (...args) => {
const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.PATCH, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
return send(requestAdapter, requestInfo, metadata);
};
case "put":
return (...args) => {
const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.PUT, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
return send(requestAdapter, requestInfo, metadata);
};
case "delete":
return (...args) => {
const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.DELETE, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
return send(requestAdapter, requestInfo, metadata);
};
case "post":
return (...args) => {
const requestInfo = toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.POST, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
return send(requestAdapter, requestInfo, metadata);
};
case "toGetRequestInformation":
return (requestConfiguration) => {
return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.GET, undefined, undefined, requestConfiguration);
};
case "toPatchRequestInformation":
return (...args) => {
return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.PATCH, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
};
case "toPutRequestInformation":
return (...args) => {
return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.PUT, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
};
case "toDeleteRequestInformation":
return (...args) => {
return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.DELETE, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
};
case "toPostRequestInformation":
return (...args) => {
return toRequestInformation(metadata.uriTemplate, pathParameters, metadata, requestAdapter, HttpMethod.POST, args.length > 0 ? args[0] : undefined, getRequestMediaTypeUserDefinedValue(metadata, args), getRequestConfigurationValue(args));
};
default:
break;
}
}
}
}
if (navigationMetadata) {
const navigationCandidate = navigationMetadata[name];
if (navigationCandidate) {
if (!navigationCandidate.pathParametersMappings || navigationCandidate.pathParametersMappings.length === 0) {
// navigation property
return apiClientProxifier(requestAdapter, getPathParameters(pathParameters), navigationCandidate.navigationMetadata, navigationCandidate.requestsMetadata);
}
return (...argArray) => {
// navigation method like indexers or multiple path parameters
const downWardPathParameters = getPathParameters(pathParameters);
if (navigationCandidate.pathParametersMappings && navigationCandidate.pathParametersMappings.length > 0) {
for (let i = 0; i < argArray.length; i++) {
const element = argArray[i];
if (element === undefined || element === null || element === "") {
throw new Error(`path parameter ${navigationCandidate.pathParametersMappings[i]} cannot be undefined`);
}
else {
downWardPathParameters[navigationCandidate.pathParametersMappings[i]] = element;
}
}
}
return apiClientProxifier(requestAdapter, downWardPathParameters, navigationCandidate.navigationMetadata, navigationCandidate.requestsMetadata);
};
}
if (name === "then") {
// handle returning proxy from an async method
return undefined;
}
throw new Error(`couldn't find navigation property ${name} data: ${JSON.stringify(navigationMetadata)}`);
}
},
});
};
//# sourceMappingURL=apiClientProxifier.js.map